{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "Untitled5.ipynb",
      "provenance": [],
      "collapsed_sections": []
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Ds480Dzpk6vM",
        "outputId": "63afb61b-643f-4be6-afd1-5b63eade7506"
      },
      "source": [
        "!python -m pip install paddlepaddle -i https://mirror.baidu.com/pypi/simple"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Looking in indexes: https://mirror.baidu.com/pypi/simple\n",
            "Requirement already satisfied: paddlepaddle in /usr/local/lib/python3.7/dist-packages (2.1.2)\n",
            "Requirement already satisfied: astor in /usr/local/lib/python3.7/dist-packages (from paddlepaddle) (0.8.1)\n",
            "Requirement already satisfied: Pillow in /usr/local/lib/python3.7/dist-packages (from paddlepaddle) (7.1.2)\n",
            "Requirement already satisfied: protobuf>=3.1.0 in /usr/local/lib/python3.7/dist-packages (from paddlepaddle) (3.17.3)\n",
            "Requirement already satisfied: numpy>=1.13 in /usr/local/lib/python3.7/dist-packages (from paddlepaddle) (1.19.5)\n",
            "Requirement already satisfied: gast<=0.4.0,>=0.3.3 in /usr/local/lib/python3.7/dist-packages (from paddlepaddle) (0.4.0)\n",
            "Requirement already satisfied: requests>=2.20.0 in /usr/local/lib/python3.7/dist-packages (from paddlepaddle) (2.23.0)\n",
            "Requirement already satisfied: decorator in /usr/local/lib/python3.7/dist-packages (from paddlepaddle) (4.4.2)\n",
            "Requirement already satisfied: six in /usr/local/lib/python3.7/dist-packages (from paddlepaddle) (1.15.0)\n",
            "Requirement already satisfied: chardet<4,>=3.0.2 in /usr/local/lib/python3.7/dist-packages (from requests>=2.20.0->paddlepaddle) (3.0.4)\n",
            "Requirement already satisfied: certifi>=2017.4.17 in /usr/local/lib/python3.7/dist-packages (from requests>=2.20.0->paddlepaddle) (2021.5.30)\n",
            "Requirement already satisfied: idna<3,>=2.5 in /usr/local/lib/python3.7/dist-packages (from requests>=2.20.0->paddlepaddle) (2.10)\n",
            "Requirement already satisfied: urllib3!=1.25.0,!=1.25.1,<1.26,>=1.21.1 in /usr/local/lib/python3.7/dist-packages (from requests>=2.20.0->paddlepaddle) (1.24.3)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "xfs9HN0Ek7fS",
        "outputId": "5f76731b-5e4a-4986-c76a-f4d525227739"
      },
      "source": [
        "!git clone https://github.com/PaddlePaddle/PaddleGAN.git"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Cloning into 'PaddleGAN'...\n",
            "remote: Enumerating objects: 3755, done.\u001b[K\n",
            "remote: Counting objects: 100% (39/39), done.\u001b[K\n",
            "remote: Compressing objects: 100% (35/35), done.\u001b[K\n",
            "remote: Total 3755 (delta 11), reused 14 (delta 4), pack-reused 3716\u001b[K\n",
            "Receiving objects: 100% (3755/3755), 161.23 MiB | 33.77 MiB/s, done.\n",
            "Resolving deltas: 100% (2370/2370), done.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "GuyDoHTYl9RC"
      },
      "source": [
        "import os\n",
        "import random\n",
        "import paddle\n",
        "import paddle.nn as nn\n",
        "\n",
        "import paddle.optimizer as optim\n",
        "import paddle.vision.datasets as dset\n",
        "import paddle.vision.transforms as transforms\n",
        "\n",
        "import numpy as np\n",
        "import matplotlib.pyplot as plt\n",
        "import matplotlib.animation as animation"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "aC5euX-Rnfrh"
      },
      "source": [
        "demo_dataset=paddle.vision.datasets.MNIST(mode='train')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 44
        },
        "id": "wQQlJLeMpB_c",
        "outputId": "fc347dab-daa3-437b-8f41-6746b3b387f1"
      },
      "source": [
        "demo_dataset[0][0]"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "image/png": "iVBORw0KGgoAAAANSUhEUgAAABwAAAAcCAAAAABXZoBIAAABAElEQVR4nGNgGMyAWUhIqK5jvdSy/9/rGRgYGFhgEnJsVjYCwQwMDAxPJgV+vniQgYGBgREqZ7iXH8r6l/SV4dn7m8gmCt3++/fv37/Htn3/iMW+gDnZf/+e5WbQnoXNNXyMs/5GoQoxwVmf/n9kSGFiwAW49/11wynJoPzx4YIcRlyygR/+/i2XxCWru+vv32nSuGQFYv/83Y3b4p9/fzpAmSyoMnohpiwM1w5h06Q+5enfv39/bcMiJVF09+/fv39P+mFKiTtd/fv3799jgZiBJLT69t+/f/8eDuDEkDJf8+jv379/v7Ryo4qzMDAwMAQGMjBc3/y35wM2V1IfAABFF16Aa0wAOwAAAABJRU5ErkJggg==\n",
            "text/plain": [
              "<PIL.Image.Image image mode=L size=28x28 at 0x7FAF056B38D0>"
            ]
          },
          "metadata": {},
          "execution_count": 6
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "cqaUzxAXpTn_"
      },
      "source": [
        "dataset=paddle.vision.datasets.MNIST(mode='train',\n",
        "                  transform=transforms.Compose([\n",
        "                      transforms.Resize((32,32)),\n",
        "                      transforms.Normalize([127.5],[127.5])\n",
        "                                                 \n",
        "                  ]))\n",
        "                      "
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "SAa9CiTGqxZg"
      },
      "source": [
        "dataloader=paddle.io.DataLoader(dataset,batch_size=32,shuffle=True,num_workers=4)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "cqiUFrgLr7CP",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "9bbbc3f3-f864-4d23-c746-cc00f186265b"
      },
      "source": [
        "for data in dataloader:\n",
        "  break\n",
        "\n",
        "data[0].shape"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[32, 1, 32, 32]"
            ]
          },
          "metadata": {},
          "execution_count": 10
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "VuiOWRlcsGeO"
      },
      "source": [
        "@paddle.no_grad()\n",
        "def normal_(x,mean=0.,std=1.):\n",
        "  temp_value=paddle.normal(mean,std,shape=x.shape)\n",
        "  x.set_value(temp_value)\n",
        "  return x\n",
        "  \n",
        "@paddle.no_grad()\n",
        "def iniform_(x,a=-1.,b=1.):\n",
        "  temp_value=paddle.uniform(min=a,max=b,shape=x.shape)\n",
        "  x.set_value(temp_value)\n",
        "  return x\n",
        "\n",
        "@paddle.no_grad()\n",
        "def constant_(x,value):\n",
        "  temp_value=paddle.full(x.shape,value,x.dtype)\n",
        "  x.set_value(temp_value)\n",
        "  return x\n",
        "\n",
        "\n",
        "def weights_init(m):\n",
        "  classname=m.__class__.__name__\n",
        "  if hasattr(m,'weight')and classname.find('Conv')!=-1:\n",
        "    normal_(m.weight,0.0,0.02)\n",
        "  elif classname.find('BatchNorm')!=-1:\n",
        "    normal_(m.weight,1.0,0.02)\n",
        "    constant_(m.bias,0)\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "iPLeLiimtxEg",
        "outputId": "9c2366e0-44fb-4cc6-fa24-5249b27433f7"
      },
      "source": [
        "class Generator(nn.Layer):\n",
        "  def __init__(self, ):\n",
        "    super(Generator,self).__init__()\n",
        "    self.gen=nn.Sequential(\n",
        "        nn.Conv2DTranspose(100,64*4,4,1,0,bias_attr=False),\n",
        "        nn.BatchNorm2D(64*4),\n",
        "        nn.ReLU(True),\n",
        "\n",
        "        nn.Conv2DTranspose(64*4,64*2,4,2,1,bias_attr=False),\n",
        "        nn.BatchNorm2D(64*2),\n",
        "        nn.ReLU(True),\n",
        "\n",
        "        nn.Conv2DTranspose(64*2,64,4,2,1,bias_attr=False),\n",
        "        nn.BatchNorm2D(64),\n",
        "        nn.ReLU(True),\n",
        "\n",
        "        nn.Conv2DTranspose(64,1,4,2,1,bias_attr=False),\n",
        "        nn.Tanh()\n",
        "\n",
        "\n",
        "    )\n",
        "  def forward(self,x):\n",
        "    return self.gen(x)\n",
        "\n",
        "netG=Generator()\n",
        "netG.apply(weights_init)\n",
        "\n",
        "print(netG)\n",
        "\n",
        "\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Generator(\n",
            "  (gen): Sequential(\n",
            "    (0): Conv2DTranspose(100, 256, kernel_size=[4, 4], data_format=NCHW)\n",
            "    (1): BatchNorm2D(num_features=256, momentum=0.9, epsilon=1e-05)\n",
            "    (2): ReLU(name=True)\n",
            "    (3): Conv2DTranspose(256, 128, kernel_size=[4, 4], stride=[2, 2], padding=1, data_format=NCHW)\n",
            "    (4): BatchNorm2D(num_features=128, momentum=0.9, epsilon=1e-05)\n",
            "    (5): ReLU(name=True)\n",
            "    (6): Conv2DTranspose(128, 64, kernel_size=[4, 4], stride=[2, 2], padding=1, data_format=NCHW)\n",
            "    (7): BatchNorm2D(num_features=64, momentum=0.9, epsilon=1e-05)\n",
            "    (8): ReLU(name=True)\n",
            "    (9): Conv2DTranspose(64, 1, kernel_size=[4, 4], stride=[2, 2], padding=1, data_format=NCHW)\n",
            "    (10): Tanh()\n",
            "  )\n",
            ")\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "uirWHtJ20ur2",
        "outputId": "0d20f7df-55fa-400e-c87f-650534831b4e"
      },
      "source": [
        "class Discriminator(nn.Layer):\n",
        "  def __init__(self, ):\n",
        "    super(Discriminator,self).__init__()\n",
        "    self.dis=nn.Sequential(\n",
        "        nn.Conv2D(1,64,4,2,1,bias_attr=False),\n",
        "        nn.LeakyReLU(0.2),\n",
        "\n",
        "        nn.Conv2D(64,64*2,4,2,1,bias_attr=False),\n",
        "        nn.BatchNorm2D(64*2),\n",
        "        nn.LeakyReLU(0.2),\n",
        "\n",
        "        nn.Conv2D(64*2,64*4,4,2,1,bias_attr=False),\n",
        "        nn.BatchNorm2D(64*4),\n",
        "        nn.LeakyReLU(0.2),\n",
        "\n",
        "        nn.Conv2D(64*4,1,4,1,0,bias_attr=False),\n",
        "        nn.Sigmoid()\n",
        "\n",
        "\n",
        "\n",
        "    )\n",
        "  def forward(self,x):\n",
        "    return self.dis(x)\n",
        "    \n",
        "netD=Discriminator()\n",
        "netD.apply(weights_init)\n",
        "print(netD)\n",
        "\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Discriminator(\n",
            "  (dis): Sequential(\n",
            "    (0): Conv2D(1, 64, kernel_size=[4, 4], stride=[2, 2], padding=1, data_format=NCHW)\n",
            "    (1): LeakyReLU(negative_slope=0.2)\n",
            "    (2): Conv2D(64, 128, kernel_size=[4, 4], stride=[2, 2], padding=1, data_format=NCHW)\n",
            "    (3): BatchNorm2D(num_features=128, momentum=0.9, epsilon=1e-05)\n",
            "    (4): LeakyReLU(negative_slope=0.2)\n",
            "    (5): Conv2D(128, 256, kernel_size=[4, 4], stride=[2, 2], padding=1, data_format=NCHW)\n",
            "    (6): BatchNorm2D(num_features=256, momentum=0.9, epsilon=1e-05)\n",
            "    (7): LeakyReLU(negative_slope=0.2)\n",
            "    (8): Conv2D(256, 1, kernel_size=[4, 4], data_format=NCHW)\n",
            "    (9): Sigmoid()\n",
            "  )\n",
            ")\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "1zrKdmI6wM1g"
      },
      "source": [
        "loss=nn.BCELoss()\n",
        "fixed_noise=paddle.randn([32,100,1,1],dtype='float32')\n",
        "#标签，真实样本设为1\n",
        "real_label=1.\n",
        "fake_label=0.\n",
        "\n",
        "#优化器，每个优化器优化其中一个网络结构的参数\n",
        "optimizerD=optim.Adam(parameters=netD.parameters(),learning_rate=0.0002,beta1=0.5,beta2=0.999)\n",
        "optimizerG=optim.Adam(parameters=netG.parameters(),learning_rate=0.0002,beta1=0.5,beta2=0.999)\n",
        "\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "oIF1SqUuEw3v",
        "outputId": "180d43ee-bce8-4e9c-9314-748b72b46e0e"
      },
      "source": [
        "bs_size"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "32"
            ]
          },
          "metadata": {},
          "execution_count": 25
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "RPHRdtE6CG8G"
      },
      "source": [
        "!mkdir work"
      ],
      "execution_count": 31,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "id": "ZlpHZtV42_Kb",
        "outputId": "3a6eee60-4716-43a5-d7f4-85154f15903f"
      },
      "source": [
        "losses=[[],[]]\n",
        "now=0\n",
        "for pass_id in range(100):\n",
        "  for batch_id,(data,target) in enumerate(dataloader):\n",
        "    #########################################\n",
        "    #(1) 更新 判别器D网络 maximize log(D(x))+log(1-D(G(z)))\n",
        "    #########################################\n",
        "\n",
        "    optimizerD.clear_grad()\n",
        "    real_img=data\n",
        "    bs_size=real_img.shape[0]\n",
        "    label=paddle.full((bs_size,1,1,1),real_label,dtype='float32')\n",
        "    real_out=netD(real_img)\n",
        "    errD_real=loss(real_out,label)\n",
        "    errD_real.backward()\n",
        "\n",
        "    noise=paddle.randn([bs_size,100,1,1],'float32')\n",
        "    fake_img=netG(noise)\n",
        "    label=paddle.full((bs_size,1,1,1),fake_label,dtype='float32')\n",
        "    fake_out=netD(fake_img.detach())\n",
        "    errD_fake=loss(fake_out,label)\n",
        "    errD_fake.backward()\n",
        "    optimizerD.step()\n",
        "    optimizerD.clear_grad()\n",
        "\n",
        "    errD=errD_real+errD_fake\n",
        "    losses[0].append(errD.numpy()[0])\n",
        "\n",
        "\n",
        "\n",
        "    ###############################################\n",
        "    #更新生成器G网络 maximize log(D(G(z)))\n",
        "    ###############################################\n",
        "    optimizerG.clear_grad()\n",
        "    noise=paddle.randn([bs_size,100,1,1],'float32')\n",
        "    fake=netG(noise)\n",
        "    label=paddle.full((bs_size,1,1,1),real_label,dtype=np.float32,)\n",
        "    output=netD(fake)\n",
        "    errG=loss(output,label)\n",
        "    errG.backward()\n",
        "    optimizerG.step()\n",
        "    optimizerG.clear_grad()\n",
        "\n",
        "    losses[1].append(errG.numpy()[0])\n",
        "\n",
        "    #############################\n",
        "    #可视化\n",
        "    #############################\n",
        "    if batch_id % 100==0:\n",
        "      generated_image=netG(noise).numpy()\n",
        "      imgs=[]\n",
        "      plt.figure(figsize=(15,15))\n",
        "      try:\n",
        "        for i in range(10):\n",
        "          image=generated_image[i].transpose()\n",
        "          image=np.where(image>0,image,0)\n",
        "          image=image.transpose((1,0,2))\n",
        "          plt.subplot(10,10,i+1)\n",
        "\n",
        "          plt.imshow(image[...,0],vmin=-1,vmax=1)\n",
        "          plt.axis('off')\n",
        "          plt.xticks([])\n",
        "          plt.yticks([])\n",
        "          plt.subplots_adjust(wspace=0.1,hspace=0.1)\n",
        "        msg='Epoch ID={0} Batch ID={1} \\n\\n D-Loss={2} G-Loss={3}'.format(pass_id,batch_id,errD.numpy()[0],errG.numpy()[0])\n",
        "        print(msg)\n",
        "        plt.suptitle(msg,fontsize=20)\n",
        "        plt.draw()\n",
        "        plt.savefig('{}/{:04d}_{:04d}.png'.format('work',pass_id,batch_id))\n",
        "        plt.pause(0.01)\n",
        "      except IOError:\n",
        "        print(IOError)\n",
        "  paddle.save(netG.state_dict(),\"work/generator.params\")\n"
      ],
      "execution_count": 33,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "/usr/local/lib/python3.7/dist-packages/paddle/nn/layer/norm.py:641: UserWarning: When training, we now always track global mean and variance.\n",
            "  \"When training, we now always track global mean and variance.\")\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch ID=0 Batch ID=0 \n",
            "\n",
            " D-Loss=0.6199130415916443 G-Loss=4.968353748321533\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "iVBORw0KGgoAAAANSUhEUgAAA1EAAADFCAYAAAC1mnhiAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nOzdd5xcZ3X4/8+5d9r21UqrZtmWZRsbG4MxLRADpiUQegstgGmhBL5ASKEFDCGBJIQWQkggxEDo8KOXUGxjMNXYgHuXZcvqu9o69d7z++M8ox2NZnZnVitLWp336zWv2b33ub3MPU+7oqo455xzzjnnnOtMdLhXwDnnnHPOOeeOJh5EOeecc84551wXPIhyzjnnnHPOuS54EOWcc84555xzXfAgyjnnnHPOOee64EGUc84555xzznXBgyjnnDtIInKBiKiInHe418UdOuEYX3K418M559zh50GUc+6wCw+nC33OO9zreXcQkfNaPaw3DG/8zIrINhG5VET+RUTuezes3xki8kUR2SkiJRG5QUTeISI9Xc5nc4vtqYrIVhH5soj8wRKt72YR2bwU81pKInJJq/O6YXj9UxORcRG5Puz3F4lI/yFet1hEXi8ivxeRooiMich3ROQhh3K5zjl3NMkc7hVwzrkG75hn3Oa7ayWOcLcDF4a/c8AocA7wV8BfichngZer6vRSL1hEHgRcBGSBLwN3AI8E3gY8SkQeparlLmf7QWBv+LsfuDfwNODJIvIkVf3ukqz80eeT2DkvwACwCXg08EzgH0XkJar6naVeqIgI8HngGcANwIeBEeBZwKUi8nRV/fpSL9c55442HkQ5544YqnrB4V6Ho8DmVvtJRM4GPgU8F3vofdxSLlREYuB/gF7gyar6jTA8Ar4IPB14PfCeLmf9AVXd3LSsNwDvBf4WOFaDqAtV9ZLGASJSAN4AvBP4qog8RlUvXeLlPhsLoH4GPEpVS2HZHwV+CnxMRC5S1aklXq5zzh1VvDqfc+6o09gGSUReKCJXhmpHO0XkEyKyts10p4rIp0KVsYqI3BX+P7VN+lhEXiEil4nIRFjGzSLy8XmmeYaI/CpUtRsTkc+LyHFLuf2tqOpvsZKKXcBjReQpS7yIhwP3BC6tB1BhuSnwN+HfV4SSjIP1/fA92jhQRHIi8upQtex2ESmHffxDEXlcU9rzRESBE4ETm6rIXdiU9vRw3mwO89wpIj8RkVe2WjkRWSUi/xWqUpZF5BoRedESbPe8VLWkqv8AvAsrhfzgIVhMfZvfWg+gwrJ/DXwBOybPOATLdc65o4oHUc65o9nrgY8CvwM+gFU/ehHwMxFpfgB/AHA58GfAr7GSjl+E/y8P4xvT57BSkP8Ajgc+C3wI+A3wVOAPW6zPq4D/xaph/TtwNVYN6ocikj/orV2Aqu4E/jP8+7wlnv0jw/f3Wiz3VuBGLGDZtATLenT4vrxp+AgWOAwAPwDeB3wDuC/wHRF5aUPazVj10InweUfD52v1RCLyeOAK4IXANWGeXwFi5oLDRsPAZcCDsSqNnwTWA58QkRcuZmMX4b1AEThbRM5cqpmGkq6HALPAT1okqZcKPrLFOOecO6Z4dT7n3BFDRC5oM6qkqq2qiT0OeJCqXtkwj/cDr8Oqlb0kDBOsqtsg8Geq+pmG9M/C2oB8WkTOCCUrABcAjwG+CTyzsa1PCIgGW6zPY4EHqOpVDWk/CzwHeDJW7e1QuwR4K/DAxoEicj6wsYv5bFbVCxv+Py1839gm/U3APcLnli6W8zoRqbeJ6gPOwvb7z4A3NaUdB05U1TsbB4rIEBbY/LOIfEZVi6GK4AVhu1tWFRWRVVhwnAEeqao/bhq/ocX63gf4b6zdWRLSfQD4PVb98JOdbfbiqeqUiPwGOBc7zteE9dgInN/l7C5sqE55MhY83qqqtRZpbwrf9+hyGc45t+x4EOWcO5K8vc3wCVq3tfl0YwAVXICVRj1XRF4Vgp+HAKcDP28MoABU9Qsi8mrsgfRcrPF8jJUqFYFXNHeWEP7f1WJ9PtQYQAUfw4KoB3L3BFFbw/do0/DzsSp5nfoxcx1YAAyF74k26evDh7tYBsBrWwy7AwtutjcODPv9zubEqjohIp8A/hV4ANBpO6EXYsHwh5oDqDDfA5aFldL8ZT2ACumuFZHLgIeJSP+h6NSjhVbHeSPtr6F2LmGu05ZDdYydc27Z8ep8zrkjhqpKm0+7h7ZWD74TwG+BAtaGB6z3OrCe5VqpD693EX469kD5e1W9q4tNaK5+BhYQAKzoYj4Ho94mSRsHqup58+zfVp/z7qb1Pam+TKAHK4n6BdYr3KebE4vImSJyoYjcGtqoaWj79K8hSTftz+rdqHfTecVNqjrZYvhhP86qekmXx1iaO69wzjnXGS+Jcs4dzXa0GV4vwRhq+t7WJn19+HDT99YWaeezt8WwerWouMt5Ldb68N2qpOxg1EshhtqMrw9vtQ86EjoyuFpEnoeVKD1XRP5NVX8BIPbuqIuw364fYe2hJoEUOBurMtlN27PFHOd227ccjvMhP8bOObdceBDlnDuarWkzvN4730TTd8te+4B1TenqD4mHvFe9Q+AR4fuXjQOXoE3UDeG7XXuYem+F7dpMdUxVqyJyBba+D8JKpsDaevUAj2jR/febsCCqG43Hubka5hFLRAaA+4V/f9kwfCMH1ybqFiABNolIpkW7qCU7xs45d7TzIMo5dzR7ONZhxD6hk4GzgRJwXRhcbzd1Xpv51AOPK8L39dgD9r1FZH2XVfoOGxFZDbw8/PuZptHnc3Btoi4C3oJ1nvHupuVuwoKr24Fbu1jGfOrV4hqrnZ8CjLWpgtZu2xKsO/BWfoF11/04WvQ6eAT7ayyYvEJVr2sYvpGDaBOlqiUR+Rnw0PC5uCltvRv5dtVinXPumOFtopxzR7Pni8h9m4ZdgFU7+lxDhxCXYSUp54rIfu+4Cf8/FMtd/ylA6DTgI9iD6kebuycP7ytq7rjhsBKR+2Ddfq8CvtP4LidYkjZRP8aC0oeJyJMalhsB/xT+/aiqKgcpdDf/0Ibl1m0GRkTk3k3pXwL8cZvZ7QFGRaSnxbhPYtUBXykiD2uxHq165ztsRKQgIm/GgtkKTZ1yLFGbqP8I3+8KXZ7Xl/0ArLv+XVgX8M45d0zzkijn3BFjni7OAb4WXijb6LvAZSLyRaxdU72Hvc3AG+uJVFXDO3x+AHxBRL6OlTadBjwFmAJe0NC9Odj7hB4EPBG4UUS+FdIdD/wRVhpw4aI29OBsbNhPWSxouh9z1bv+F3jFUi9UVZPwQtmLgC+LyJeBLcCjgPtjger7FzHrxi7OC1hp05Ow36cPq+oVDWk/gAVLPw3HfCIs+1zsnU2tXgL7I6x91fdE5FKgDPxOVb+pqrtF5Llh2otF5LtYV+WDwL2xY33SIrZpKZwvIueFvwew9289DHtX1jbgxar600Ow3M8DT8P25ZUi8k1gJRZAxcDL2nSs4ZxzxxQPopxzR5L5qiJtxnrda/R+4KvYe6GeBUxjgc2bw4tn91HVX4bc9LdiL3N9IrAb+Bzw96p6Q1P6iog8FgtIXoB1hy3AXWGZh+IBthMnMrefSli1w5uwF7B+pkWguWQa9uE7sEByAKvC907gPc1dwXeosTQlBcawKmYfV9X9uoRX1e+JyBOxY/gsrKrer7DqmJtoHUS9C+tA4onYC5JjrATqm2Ge3xaR+2PveHpU2K5xLMh+d4v53V3qL+5NsPN6O/BDLOPgS6o6cygWGjIcnoO9p+vFwGuw8+xS4F2q+rNDsVznnDvayBLUvHDOubtVKIl5Oy06GHDOOeecO9S8TZRzzjnnnHPOdcGDKOecc84555zrggdRzjnnnHPOOdcFbxPlnHPOOeecc13wkijnnHPOOeec64IHUc4555xzzjnXBQ+inHPOOeecc64LHkQ555xzzjnnXBc8iHLOOeecc865LngQ5ZxzzjnnnHNd8CDKOeecc84557rgQZRzzjnnnHPOdcGDKOecc84555zrggdRzjnnnHPOOdcFD6Kcc84555xzrgseRDnnnHPOOedcFzyIcs4555xzzrkueBDlnHPOOeecc13wIMo555xzzjnnuuBBlHPOOeecc851wYMo55xzzjnnnOuCB1HOOeecc8451wUPopxzzjnnnHOuCx5EOeecc84551wXPIhyzjnnnHPOuS54EOWcc84555xzXfAgyjnnnHPOOee64EGUc84555xzznXBgyjnnHPOOeec64IHUcuAiFwoItrwSURkQkRuEZGvicirRWTlIuetIqJLvc5HOhF5oYj8SkSmw768RESesMh55UXkDSLyaxGZFJEZEblRRD4pIqNNae8pIu8Qka+LyJaGY5pZYBlPD+s4ISJFEblGRN4kIrk26QdE5B9E5HoRKYnIuIj8n4g8qk36rtdLRP5aRL4jIpvDfpwUkatE5H0ismGe6c4QkS+KyM6wbjeEZffMtw8apv94w/qdskTbcknTNdb8KbSYJicifyMivxOR2bD9PxWRP22zjA0i8hYR+ZKI3CwiabttaDHtKSLyMRG5Leyz3SLyCxF5QwfT/lnDdry0g/QiIj+Yb7+JyIvDvefmhnP+urCOpy20jDbL7Qv3su+JyDYRKYfz6kYR+ZyIPEdEsl3Oc3PYho2LWaejXSfHcoHpTxGR/xGRO0WkEo7Lp0Xk5AWmO0dEPhumK4vIDhH5sYi8oEXaWESeJyI/EZHt4Vq6MSz3zBbpzwr3gCtFZFeY/x0i8kMReZqISItpLljg+n5si2m6ur91sAwVkVsW2G8dHa+wDz4Trr+iiGwVkYtF5FkicsBzn4j8k4j8KOynooiMhf33dmnx7CAip4rI34rIRWGaSjiGXxeRR7RZp67vb3Lgs03z5/Ql2JbjReQjIvLLcH6VReSucL69SLq8p7hji6gec8/Hy46IXAi8EPg68NsweAA4HngosBaYBF6rqhd2OW8FUNUDfniWKxF5L/AG4E7gy0AOeDYwArxGVT/cxbzWAt8HzgIuA34JJMAJwHnAo1X16ob0rwPeH9LcBGwECkBWVWttlvGPwJuAaeArwBh23O8P/Ah4nKpWG9KvAH4KnAFcA/wQ6AeeDKwCXqqq/920jMWs181hnX4H7ACywH2Bh2Pn43mqemXTNA8CLgppvwzcATwybMtlwKNUtdxqeWH6JwLfCMvtB05V1ZuXYFsuCev9jjaLflfjtGLB6/9hx3gz8B0s0+pPsGP/96r6tqZlPAX4KqDAbdj5NtxqG5qmexrwWaAKfCtMOwScBvSo6h/OM+3xwFVAjO2vl6nqx9ulD9O8Btt/VdrsNxG5CFgHXAFsB1LgTOCPsP3+FFX97nzLaZrfQ4AvABuwc+ki7NyIsP35cGANcLmqPqCL+W4GTgROUtXNnU63XHRyLOeZ9v7YcRjA7jNXYvvyqcAsLa7vMN2rgQ8C48C3ga3YuX4v4E5VfXZT+i8Af4rdj78JTGH308eG9X6cql7UkP584L3AL4DbgQnsN/CJ2P3t06q6X7AmIhcAbwc+iV2vzf63xX2kq/ubiJyH3Q9aeSJwDvDvqvrqNmk6vfaeCPx/2DX3DeCWsN1Pxfbzx1X1ZU3TVLBr9VpgJ9AH/AF2370L+ANVvaMh/eeBZ4X0P8V+c04DnoTdS16rqh9qWkbX97eGZ5sPAntbJPmwqu4+yG05D3t2+iVwa9iWlcDjsGeoi4E/6vS6cMcYVfXPUf4BLsRuTOe3GJcB/hwohjTP6XLeaqfJ4d/Ou2lfPiRs883AiobhG4E9QAnY2OG8IuBSoAw8scV4AeKmYacBD8IefsF+0BXItFnGOWH8OLCpad7/Ecb9ZdM0HwzDv9I4X2A1sAV7ANpwMOsV0hTaDH9ZmPY7TcNj7IdPgSc17ccvh+FvnGd5o9gD++eBS0L6U1qkW8y2XNLNdQC8PszzZ0Bfw/B+4HLsAef+TdNswILfwcZlttqGhmnuFc7JK4C1LcZn55lWsAD6FuBfwrJeusB2nRbOj/fMt9/mOfaPCdNc28W+PBN7KE2ANwO5Fmli4BnAxZ3Ot+nYd3RNL6dPp8dynul/F6Z5fdPwc4EalqEnTeP+KJz7/wcMLHS+Ag8Iy7ga6G0a96Iw7qKm4fk26zvYcH95YNO4C8Lw87rY/q7ub/PMJ8YyBBS498EeLyxjTIGHNw1fiwV7CpzQ4bb8Q0j/kabh5wP3bZH+4UAF+81b1zRuMfe3C7u9PhexLTkganUuYgGUAn/a6fL9c2x9DvsK+GcJDuI8QVRDmvoPzjbCw2OH8+44iALywBuxnO1Z7MHnJ+1uQFiu1Y/COpWxXKIfA69qSrcJ+C8ssCliOUVXAR8FVi7xvvxU2OYXtRj3zjDuHR3O62kh/XsOYn3a/lg2rdO/tBi3Ioy7pWn4ljD8zBbTvC6Me9vBrNcC0w6FaW9qGv7IMPzHLabZFMZtpunBrCHNV7EgamUnP9DdbAvdB1GXhnk+vsW4p4Rxn1hgHgtuA5bTnAL3XMRxeG2Y9mHMPUS2DaKwDJlfYQ+0+cWeA1jAX+ki/UVhOf/QQdpu16W+DRs7SBsBrwB+jZVAzIS/X0nrh7CHYiUnd2L3t+1Y6cjbm9KtwUpObgjz3Bv+vpCGjJGl/BzssWy4Hne02favhfEPaxr+u7CNHd23sdIOBT7YYtxIGHdVF9v9/jDN85qG18//85Zg37a8v82T/okh/c+X4nhhv5ETbebzjTDd/Tpct/uE9D/oYvu/H6Z5+gLpLuEQBFFLvC2vDdO85WCX75/l+emq/rM7qn0Sq65wIvaw+u2lnHlD9aWHA9cD/w70YrnDXxCRs1X1zQ3p/xz4T+zB4pvAbqwk5N5YwPeRkG4d9qAyiFWJ+gpWjeEk4PnAh7ESoqXyyPD9vRbjvgv8XUjz9g7m9dzw/TkRWQM8AdvG7cD3VXXrQa4rWO4iWDWE/ajquIiMA5tE5CRVvW2haRqGPQoL0A6FJ4bv3zcNb7vvVfVWEbkRuAf2ALdf24FQhecpWDWxPXJgs4clISLPws69CnAdlgveqnphp/v4YNZlEHg88DtVvU5EHoiVAsRh3b6vqpU2094Ty9H+oKpeKiKPbJWuyVux6koPVtXyYvaxiJyLVeG5osP0JwOPwB4M/3mh9Hpoq9x8Grum7wA+jj1cPRW7V50LPK+eUKwNzbexjKRvMFdl7Z7AqwjVQkWkF6umejLwA+xeKNh9+slYCWyrc+hgHeyxrJ/fm1U1bTG+8Ry/FEBE7oXd378GjIW2M/fD9uNvsVLE5nldE74fKSI9qlpsGFdvo/rDTlY47Ov6eX5Vm2TnhmqKMRao/Eibqot1oN39rZ0/D9//NU+abo7XNcD9RORcVf1pfaCIrAYeiGVaXtvhunW7LWBVDcFKI5fK48L9LsEyUy9S1cku59HVtohIjFW/7ngad+zxIOoYoaqpiPwE+3F+IEscRGFtiB6OBRpPqj/MiMg7sBy0N4nIt1T1ZyH9y7EH0fuo6s7GGYnIqoZ/n4E9fLxOVT/YlK4Py0mv/z+MlaR042uq+tuG+R0HTKvqthZpbwrf9+hw3vW2GQ8EPoAFlXVVEXmnqr6ry/VtVv+BP6l5RNgfK8K/p2H10OvTrAvTNP+YbmpIvyTEOivYgFVlOwt4NNZW4Y1NSevLvLHNrG7C9v09aAiiRORErIri/6rq15dqvdv4fNP/O0XkL1T1y03DdwOnYvv4uqZx9X18QosHw27cDysd2SwiXwSe2TR+i4g8Q1V/3ThQrDH6p7ESyTfTARF5APAWrFT18k5XUESegVU57MGO259gJclt2300qbfn+o2qTnS63KUmIs/BAqgrsdKV6TD8rVjp+XNF5Nuq+tkwycuwY3Oeqv6uaV6N97dHYQHUB1T19U3pclipQ+OwC7pc9UtU9ZKmeSzqWDap33dOFBFRVW0a3+o+Ur8f7sRKIR7WNM1VIvI0bWgfo6pXi8j7seqx14vIt7A2UWdibaI+jwUYBwgdFvwZFhCtwTIc1gPvVtV2D8V/3/R/WUT+BSuZb97G+nI6vb+1mnYD1vZmAmvz1ypNt8fr9VjbyB+KyNexgHYVlsm0F3huu3uOiPxV2I4hrA3RuVgA8Z4Ollu/Fz8Kq4lyaSfTdOgjTf9PicibVPXf51mXrrYlXJevxjIxRrGqx6cAn1XVbx70Frjl6XAXhfnn4D90UJ0vpHsPLeoELzBNR9X5sAfcFDi9xbiX0FR9CfgNVq1jxQLzfU2Y9s87WIeN9fXt4nN+w/Trw7A728w/G8aXO9x39XZoNaxk7iTshv405uqmL3TMNjN/db4/ZK5N1MaG4RKWWd/O5zSM+1gY9iUa2mRhPxy3d7KNC61XU9pfNO3zX9G6rVK9Gsij28znMy22JcIeyLayfxu2S1ja6nyvx3K+j8NKQk8D/hGrppUAj21K/5Ywz8toqD6LNXL+VcO+WDfPMufdBuaqOtWw0tjnYEHziVipjQK7gFVN070zrPODG4ZdQJvqfFgAdD1WWpBtGN7Jfvt807G/kaa2YAscm78J032+zfjXhXVv/GzsYv71bZh3GqyUSLEG5s3jHkVT2xysxFyBeyww33pVrn/scH27vb9dsFTHssW63BimeW3T8IeEc1KB/2sY/rcN5+vtWEA9iGU2fDqMu4HWbd5ejj2YN27b5TRdd03TPLYpfRn4K1pUB8ZKFF+E3aMLWGclL8VqDcx7fOjw/tZm2reHaT7cZvyijhfWadDVTes1iWWatGwzFKbb3jTNd4E1HW5LHutkQoG/7iD9JSxcne/FWKciJ4TjsgnLsJ1kgeeCbrcFOL0pfYq1FW3brtQ//jnsK+CfJTiInQdR/xTS/Xv4fyMHPoBc0DSNskAQhfXOpLQPPk4K469sGPaXYdg2rJ76U4DRFtOeiOU8VrEHkz/HciFbtos5yP241EFUOaT/Xotx9YenGxaYx7w/liFNvWrRJPA/wL9iP+QlrBREgWc1pF/HXLuoq7BSso9hOcRXhuHFg12vFtOsxHL3foXlvP5x0/jFBFFvCMP+pCntJSxhEDXPtK9uPrfD8H7swUexnOAPY0HtZqxEcG8YN9+P+rzbgAVN9R/8Z7cYX3+Qf1PDsAdhD7H/3JT2AtoHUf/GXKnxovYb9rD8EKzKb5kF7lUN0y0URNXXofFzXhg3TIv7GzDcYvqNC6zHHizwbPWAnwn7dLxhWL095DjWdvNZNHXW0rBf7sQe2L4H/D+shDGeb30W+1mKY9kwzSOZu8f9AHvg/HyYf/0+8t2G9G9qOEYPbpqXYNW2m69vAT4U9u8bmSvxObch/V8ssJ5ZrLTvbWHdvtnqOLaZ9pwwTYWmzIgWaee9v7VIHzF3Hz5rqY5XWIc92LV2DlYDYhPwPuYyduY9zljJ3VOxoPYu4JwF0sfAF8P8P08Hv890cY9uMe0TmMskmvdaWeS2nIC1h5oAfg6MLNU16J/l9TnsK+CfJTiInQdR9dy+C8L/53HgA4g2TdNJELUhpPt1m/GFMP62puEvwHLxEuZyfi7mwF7L7olVdZhoWM8twP9b4v3YF+Y91Wb8qjB+R4fzq5c2vbzFuJi5B5CheebR9seyIY1gweWvsdK9aaydwB9g1ToUeETTNGuwB/vN2I/0XdgP9ikh/e0LbNuC6zXPtMNYLuFO9i+l+VKYZ8sGyQ3b8rjw/z2wQPGADhq4+4KoAhbgK029jWEPe/+I5diXsSpQn8JKs+oZA/P1njfvNmDVgOrXzQGdxWBVmRT4avg/gz1IXEtTD2a0CaKwKropLToaWcx+w3rC+j1WSntAUNEi/QvCMi7tIO3/sn8QtZHWpTMbW2zDxgXmXQN2zTN+O5A2DXs81ilGpWHZlwOPaUq3Afhv7IGwnm4X1m5qyXLBl/pYhunuiwXru8J2Xo+V2v5pmN8nG9K+Mgzb1mZebw3j398w7Pww7H0t0q/FSqemgP4O1/eNYX5/1cU21ktXDuhhtU36lve3FukeH+bbskOJxRwvrOr7GBaY97aYrt7F+PkdbsuJ2L3r6nnSxMDnwny/0Ok5xEEEUWH6O5knAF3MtrSY5tnMU1LoH/94m6hjhNgL9up10H8JoFZXfila4NfbKqxtM35dUzrC8j8FfCq03XkIllv0YuD/ROR0Vd0V0l0HPCu05bgPVuf8NcAHRWRGwzuNDrZNlKrOiMhW4DgRWacHtos6NXy3a7PT7AasI4kD3m+hqomITGKBWQ9N+6YbqqpYo+QDGiaLyFnYD/EVTdPswEpRXt2Uvt7wer92NEtJVfeKyM+x0sczsQdLsP0F7ducNe//M7AqJC8SkRe1meam0Aj7qar6tYNa8RZUtSQiU1g1uj7sga4+bhqrPrNfuyMR2YQFWL/Rhvd3LUJ9f5W0dRuH8fBdf0lxP3P7ttSmcfrHRORjWIcTr8MekgV4R2jf2Eo1zOu+9WupHVWtiMiPsLYjf4B1nDCfy8L3/UVkULtoTK723qel6mFkAhgRkWzzMQv3pVVYSXDj8r8NfDu0tXwQlnv+SuBbInJfVb02pLsTeInYTjwDK+H5C6zkJMI6s6kv64Iu1/sSnWsTtaTHMqz7lcDTm4eLSL1Tmsb7SP18bfW+HzjwfIW5ziMubrHs7SJyPbZdp2FVxBfyXeDdWAbieztIDxYggl3fC5rn/tas3qHEf7YZv5jj9RDsXnSxqs62SH9xWK/7YZmv81LV20XkWuBsEVmlB76TKYvVEHgm9q66F6hqstB8l8guLEOq0+My77a0UX+X3XmLW0W33HkQdew4Hyui3kaLH6SDoapTYm9a3yQip6rqTU1J6m8wb9kjl6ruxXre+04I9l6MBXxfaUpXw34ofyMiP8Marj4Fy8UFywF8e5erv5m5FxSD5Rw/H6tP/z9NaR/XkKYTP8S6Ob4XTY2GQ299q7BSo257f+pIeIngCcA3tfNG+fWXUH523lQH77jw3diD00VYW6LHYg86+4TA4x5YW4p6z1+bmTv2zR6PBfVfwh5uNy/BOh9ARE7DHlqm6Pw4Lsk+Vuux8FbsujtZVW9pSnKv8H1b+C7Tfn+dgz20/RR72P15GH71PNM8C+0QFNsAACAASURBVAvMPoHl1nbaS2arY9+Sqt4i9qLj84C/piGguJtdibV9ehj2WoZGD8Ny49vd32awc/ui0FvmO7F7ybVN6RTrWe0aEfkaVtr+FPbf5m7vb2A5/nBojuUBwoP1c7CS1sYg+RdYSflGEekL+6VR8/kKcx1rjLZZXH14y14oW+j43IN923JO+LebXhLnXY6IrMfuUW07lGBxx2up9xdYNXewGiP7hI5Pvoj1Ivkp7LUgrXpqXHIiMsRcG6bbFkjeqOW2zKOr88Udgw53UZh/Dv7Dwi/bfRlWfSaloW1Mh/NWFqjOF9K9OaT9Gvt3VrAKu8kpcG7D8EfQuoHvN9m/ytb9aFHdDeu1T4EvLPG+7Pplu2EbT+fABvwbsIeGMfZ/EW7M3PuoFnpX0GYWrs432GLYiWEbyjS9wBHL3T6g+gsWPKZY7v8B737pZr2w4K1lex+skbhiD4mN58p8L9utV/Vr+7LdpmVcwhJV58Pa9B1QJx57IPlZmPa/OjwujwnX4s00vIR3sdvA3Et9v9y4/uHcqzesfngH++ACWlTnW8x+w9qGtHy/EVayUMWCznk7lWmY5l4hfYJ1TnBAFbdwjtTfgXPeIrZh4wLpnhvS/YqGalJYe5N6RyHPaxj+sFbnE1aFVoFXhv/PbHWdYL2JKfDLTrflYD7zXQNYTYLTaboPYyUAzS8LzzD3ku8D3o/H3Iu+30/D/R8rmSyGc+PkhuH1NnFXt1j+K8K4bex/H2nZcUm4Xn8fpnlZw/AB4LQW6XPMdc5zHQ33RBZxf2tK83chzb8t5fHCgoRquFb+qGnc8VgVQ6WhDSmWOdXqNzZi7gW1lzWNy2M9/CrWJnfe34s223AJ81dXXkvrdoT9zFVL/H7TuMVsyzmtjlNYTr1DmQXfUeefY/PjJVHLy1NEZGP4uw+70T8U+xGcwHqyaZfrNS8RuXCe0a/CqkY8DsuV+p2IfAd7wHgmVqXtn7XhnRXYTXBaRH5BeIFqWNcHYKVN9Xd/PB94uYj8FOvWehxrJPxELED4wGK2px1V/ZmIvA/r+OL3IvJl7Mf0WVh989eoVRNq9Gosh/gd2MNofV53isirsBKt34rIV7GA6jzgbKxa2t80zih0s9pYzaTeHfJ/i4iGv9+jqtc3pPnv0LXsFWH+J2EvMs4Cz9cDu/PtBXaIyA+wfZpivfw9GHtYeKY25SguYr3OAb4UqrXcjLUPW4lV4ToLK4F7vjZU/VCr4vgiLNf+y2Hfb8FKAO6PBXfv5yAtYlseDnw0nIO3Yvv4BKx3sSGsus5+xzG4XkR+j7UTKWH75NFYcPNkPTAnvvk6Oz18/1OoMgjw8abr6N+wkrunY+fYj7CHwqdgJWTvU9Uft9sXh8jxWGnx5Vip1laslPhs7PhXsWBtvP0s5qh1c/3HWCD9HuB1InIx4SEVe9h6BJZrfBv2HqduvVdEptuMe5uqflZEnoy19amXFCm2n0/CMnM+0zDNh7BqwZcx1+7wflhVvduZ6yr/McC/hOvkRuwhdwN2H633Dna4vRt4IdZ73YUNwx8BfFxEfoi1T+nHzsWTsaC+Vanh32EB5uuAB4f9swbriKOAvcqisUT1I9j7t+4N3Cgi38CqA56D7csE61iisWTh4yKyEgtut4Q0G7HrtQfL6PtEQ/qVwHXhfL0OC8pGw/adhJUwP6fpntj1/a0u1LZ4Sfh3vndDdU1V7xKRv8d+i74buoS/HrtGnkYIQFT1Ow2T/Qnw7nB/uw3LLFyD3fc2YferlzUt6qNhut3Y9f22FtWDL9EDu9e/sOHfhe5vp2PdtDdeG8dh18xa7F780qZlLmZb3gb8YajdsgVrZ3c89jwzjGWUvRvnWjncUZx/Dv7DXElU/ZNgVZhuwX4wXs0ie5dpmm+7z3BIW8BKpK7GchWnsOpBz2kx31dggdSt2E1rDKsy8zc0NNDH2hL8B/am+zHmcvH/B7jXIdyn5zPXUcMU9i6YJ7RJe0HYDxe0GX8e1vPWOPYwdTPWBfVwi7QbO9jf5zVN80IswNgT5n8H9nLle7ZZnyxWTeSGsH0zWJXGN9OiMfJi1gsLMt6Ltb/bwVzpw+/C8OPn2fdnYA/Mu7FA+UbsoaBtI+0W87iENrmci9iWs7Br7Kqwj6vhXPwJ1javZU9f2APwVdi1WMQeZt7DPNdiB+t1fotpclhVt6tY4LqbZ7n1c3gpSqJWAO8K+2dbOCdnsAfUj7Y7LztYXl/Y39/HHobq870ZqxL17HbHooNtmO9zdkgbYRlGl2P3rFksw+cvaMqJx4Ktz2GvfpgO58DVWG74aEO6e2K9pl2OtfEoh3X6MvCQxeynRe7blscyjLuw1bmH5fp/BbvflLH728VY0NO2dzbsQf4fmOtwZW84pgd0H9+Q/m3YPWoGu/7uwqqSPbBF+j9j7iXF08x1nPMtLDNMmtIPYkHvLxrOq2nsXvUeYHWLZRzM/a3eIUzLDiUO9niF8U/G2vPswqqiTWLBwCs5sPTwXlgJ6W+xe24Ny3T9NXZfaFUKfwkLXzcXtJiu4/sbFsj8J5Y5uCvs4wksOH4LTR35HMS2PB7rlObGkLaKBWw/xNqtdd3hkH+OnY+oKs4555xzzjnnOhMd7hVwzjnnnHPOuaOJB1HOOeecc8451wUPopxzzjnnnHOuCx5EOeecc84551wXPIhyzjnnnHPOuS54EOWcc84555xzXfAgyjnnnHPOOee64EGUc84555xzznXBgyjnnHPOOeec64IHUc4555xzzjnXBQ+inHPOOeecc64LHkQ555xzzjnnXBc8iHLOOeecc865LngQ5ZxzzjnnnHNd8CDKOeecc84557rgQZRzzjnnnHPOdcGDKOecc84555zrggdRzjnnnHPOOdcFD6Kcc84555xzrgseRDnnnHPOOedcFzyIcs4555xzzrkueBDlnHPOOeecc13wIMo555xzzjnnuuBBlHPOOeecc851wYMo55xzzjnnnOuCB1HOOeecc8451wUPopxzzjnnnHOuCx5EOeecc84551wXPIhyzjnnnHPOuS54EOWcc84555xzXfAgyjnnnHPOOee64EGUc84555xzznXBgyjnnHPOOeec64IHUc4555xzzjnXBQ+inHPOOeecc64LHkQ555xzzjnnXBc8iHLOOeecc865LngQ5ZxzzjnnnHNd8CDKOeecc84557rgQZRzzjnnnHPOdcGDKOecc84555zrggdRzjnnnHPOOdcFD6Kcc84555xzrgseRDnnnHPOOedcFzyIcs4555xzzrkueBDlnHPOOeecc13wIMo555xzzjnnuuBBlHPOOeecc851ITPfyJM++K96d63I0e62175BOknn+7RznexT35+d83N06fk5urT8HF16fo4uLd+fS8uv+aXn5+jSmm9/ekmUc84555xzznXBgyjnnHPOOeec64IHUc4555xzzjnXBQ+inHPOOeecc64LHkQ555xzzjnnXBc8iHLOOeecc865LngQ5ZxzzjnnnHNd8CDKOeecc84557rgQZRzzjnnnHPOdcGDKOecc84555zrQuZwr4BzRxONAFEkFdDDvTbOObeMCKS5FCKQqiA1Odxr5Fx3BFRACwlRb22/4SKAKMlMlmg6Pmyr6JaOB1HOdUqAWNFIoQaS+A+8O4bVT3/PTHBLRCNF+mrE2ZTadBap+YOmO7porBBBYaTEqat3EYUbZCQpuTghIym/3X4cxZkBv3cuAx5Euc4IaEbtwSkNw1JB0vkmOrppTtGM5YqSSRGBKJsioqSJoEmEKiHbifBpKKEKpVWSCtTCvhJ7UCCq70+FOOzX+vSJEJUiv8F2KuT82d+207yk8NDQrKLZuWsCgFJspQa+z12XNKN2H4wUMopkUvqHihSyNaayBcq5HJraPZEUpBx55tVB0qyiPQkAEq5dv27nUf99iRXNpXau1mukhJKlxrRRrIgoo4PTnNA7vm9UJClZsf3ek1vNbOQ1WtrRWNF8+J2JGp6P9ksEVML94DA+i3oQ5TqS5lOyK0rEsVKtZCyImM0gxWXarE4gNzrLKat3M1qY5oz+u+iNKhSkSlZqlDRHOc1S1ZippEA5zbC31ks5yVBMslTSmOlqnl0zfZSrWWZ290IxthtDLiXbU+X40XH6shXW9UwwmClRTjMUkxy3Tq3k1pvXEi3XfbvE5h7sQ0CaChTDw4FbUvFImVPX7WQkP8sZ/duoaszXbz+L8V0DaCWy4N+5DsmKCqtWTDPSM8t9VmxlKC6yPjfOQFRiJs1R0hy7qwPcNLuaPeU+rr7tOBjPHu7VPnqJXcPPvOcVRKJ85aazKe3qQRKvOtlO/fclN1TmPsdtZUVulrX5SfrjEkNxkeF4BoBU7d6XhK4GhuMZVkYzYZiQEDGVFphJ89wyPcruwhBaE6KKZ5geYLDGfU66k5X5GUZyM/TGFappTEJEqkKqQjHN8fO7NjI51UM6k0FmD0+p9REfRGnjb7IscKapzCXxk3JR9u3v5n2dTenvLZOJU2aiHLVaTKUawTIuMektVNjUv5uNhT2c23cDfVKjIHaLLGlElYiSxuxNeilplu21YWbTHLNJntk0x1i1D4DpSp7ZfB6tCWRT4kKNnp4KJ/SPM5Kd4dSeHYxmpphKC0wlPdQ04tZ4TevcF3fAOaqZFMknSKRIrKBCUonsocD335LKF6qcMrCLtblJHtJ3ExWNubT3FPZm+uz8Xs7qOdLtfofmq97ov00HEogzCSsKRY7rneC+vbczEk+zNjNFn1hbkgRhe9JHIaqyJTvCtdl1vvsWK9SCyBeqPLD/ViJSvt97OqVsoaEo3zXTWJFcSl9PmTMHtrEqO8Wpue0Mx7OsjMqMRHMPqQlKSZUUK0SJ9w23CjzbkyoFqVLIVEOJlu/3/YRzNJOvcerATo7Lj7M+O85gVKKiMSXNkmpERWMmkj6u7VnLTDFHGh++ar9HdBCV9iUMrp4mn63Rl6uQixJElExk5XZR+FWqR6bbJgeZnOxBU6tqRQpSjD2HpUNpf8Ka48bpy1UYyhUpxDUyUUIsSl9cYW1+gghlT7WPYprj93vWc9eOYbQaITOZZVW1TwX68xU29ezi+OwYK6MyeYGCCDFCFSXRGgk1RqMyKbAxO0ZVI6oakyDMpHl2DQ5SSrNsWbeSiVoP+ahGb1RhIC6xKb+TXikzHM/SJzVKGlPSDAnCb0Y3MNNTIJ3Keu5+g7Q/YXT9XnqzVYbzRQqZKkPZIsPZIjEpkSjFJMtPtp/M+EQfNW/AuyQ0o2isrOqf4UEDt7IynmZ9Zoq9aY4kjdBKbFWuliGNQHsTJJewYmSaE4fGycUJA5kyUcNNLxYlQqlqxEwtT6rCbC1HJY3ZPjXA5FSvBfeT2WV1r1w0hepknptro+wa7CMf1xjNTfGw/uvJxlOA7dMcCWuyE5TSLHEmoRp7NajFSHMp5FMGekqMxpMMR2WedPxV3LJylF/fdQLFLd5G5wACA2uneNC6LWwojPPw/usZiEoMR5V9zwNZqZdAKSjkBBJVYmm4H6pSVRhL+tleG2K81DtXFc33+T7Z9TOcsXY7J/SNc97gdQxEJfqkQlZS9qYFptICW6sj/GbqRHaV+rlrbJDqZB6pHr5npCM6iIp6atxnzVbW5Kc4Lj/OcDxLVhIKUiWWlCg0zqmGB88f9N6LyzmeWhpRqWRIkoikGnkQ1aG4r8rD193MCfk9nJ6/i9F4hiwpufCLnyAkKoyFIukIZaJYoFjMkRZjq0a1jPTnymzM7WY0nmQosptlQeYumfqNMmp6U0C0L0u6TMpOUlIS3UJKfT/uf9eMEUCoao2EKjPpVk4Y3suOzAC7S4NW2ucAiHtrPHTtLRxfGOP0/DZG4mmGowrDDbtoTyJMJ3muidexnUHUg6iDU28PGSureqY5K7+VAakxEAlQIdXQ5m+ZBlFEStxbo9BT4cFrb+epI5czEJVYH5fJNTwoZbF7xKwm7EqslHp7MshU0sOlk6dxeXw8kzMFKjOZZXevXKxoJoaZmPFyzLWFtazu7ePMnjsZjWeIw0NpVhJWxtNMZQpkMgnVGBRdvufboZJR4p4aQ/kSI1GJtTE8ffAKJvrz7Co9geu2DBzuNTziqMDGFeOcP/oThqMyGzKQJSaW/H7pElUSEiIRsk0FTGnD956knx3VIaarOa/G10xg46ox/uK4ixiOiqyPK2RFSLH9CyVKaZbZNMcNe9cwNttDdTJv95DD6LAFUWlPihQSJJOSzdWIIiWOLSc5jlLiSFnTP8XZA3cykplmNDMZ2qMk5LDGefVcwFQjKsSc2b+V2pqIcpJhslqgnGTY0dtPuZylMp0jmjyiY8a7lcaKjFTI5WtkszXymYR1A5OcXNjJyniarCRUNbIqF+FKj7EGfgNRhT6pclrvdnav7mO81MuW7Aqq1ZhkIrdsSk7Gir1cPnMSJ+V3sT6+mb4oBWrECCVNqIYgKosQhYepGAuq6rlQdvG3loZxKUqCVQGoqLI37WXH9AATUz1QWx778mClQzV6h4qsHZpiY2EPo5lJBqIifVIjiwJCRZWywljaw7biELsn+0hKGX8Z3kFSAXIpcSFhKFuiIAnZ8JCQqFBNl2eOquYU+qtkcgnHj46zsjDDiT27LRMPy1lO0bnzSyDRhESVrKQkCANRiSwJp/TsJBkVxod62dK/gkotRkJNiloSk6pQqWSoTOcsIK0cY5l/1YgdEwNMlvJ8Tc5hXWECsNomVY2ppBn2VnqolLPWg58Hod1LhaQcU6plqRJRJSENZ+9gtkQ6WIN6u8Zldi0fjFoaMZPmKUiNslapkrKrJsxqhjtqI2yurCINNVCykrApv5OReJocCVlJSBCrqp/2cNnkqWyeHmH3RP/h3qwjhsZKtKpMT0+F04d2MBwVyUrKrEKisDfNMZvm+W3pBK6ZPo4dpQF2TvZTKWePiNoPhyeqEMgOlzgx/DDda+Au+uMSazMTDMRFBqISg1ImLwnDUXrAg2pdHHL8q1olQdmYuZrH9F3HjGbYXhtiNs1zR3WE8WofP9h6OmNTI35zCDSn3H/jFu43tIVT8js4ObuLSJQsKSnCjGZC1TILWGOUWBKyKMOxtQv64/5rOafnNnYlg/xqZBPbykP85JZT0FJ+/oUfBURh9/gA39fTOXPlMGfmtzJCiV5JiIG9acSU5siR0hvVrCoZEAtkgWyo9tccXNVLo1JVSlovmTJlhZLG3FlZyZ7dAzCRJfLzFQTWrx/juSf8mpXxNJtyOylIQp/UyO97mLcAanvSyx3Vldw2NkJley+RP2wdPFFy/RWG+ots6BlnOIIsUQj8hVqyTDvx6Ktx+gnbWdMzxSOGr+OE7Ji1ZwjtdSbS7L57ZixKWXVfcJlFiaVGNpoljYTj+q/hj/uvsap+661jhHrm1N60lz1JPzeW1vLdO89gupinuKfnmOreOypFlLf1UpZefn7n0Fz7MrC/syE/P5HQW9cyPN8OMSlHUBMmigVm0yyVqEZVIxKEdYUJVq2eZHKmQHVnz7EVwM9DFKppzN60l1hShtMKFY34WXET26rD/HD76dx+5yorZkoEyaecvWkLZwxuZygzy1BcZDbNsbMyyK7KAD++9RRqYwVIFm7if6zQnPKIk2/ioUM3hJo/FUoq7Ep6mNEc15Y2sKM6yI+23YPtm1daBkoCqBAdAdWi794gSiAtpBArw30l1vRMsSo/zbrsXgbiImszE/RJhYGoyoDUc/kjovBAWpeg+x5KIbSNUigIRFFCVlPSeIpSVCIhojeqMNo3ze6BQagemzktGivE9W+rnrK2MMma7AR9URmA2TTLnrSPqmaYTAqUNEdOahSkSiTpvmqUo/HUvjY89QeBKLQHWDYUkkrEdDHPttlBrikfx3A8SyGqkCVhb9rLVNJDVmoUIsuZzoaHq5wkZKVGjO4rLY1JQxrI1vs6D+dv/SHM2lNZjpbWjowbxGElkPYkkFXW9E5xXHacglSpakxVY3apnat1Jc2yszbItsow5VK2bXWf+guTNWPdKjd2TS/VZVwtbbEEMpmE3myV3qhCxFwD6hnNkCy3QDU0bo6yKcO5IkPZIrmQo7wzGWA2ze/rgQvYd603VjGvS4lINKIvKjMQFYlR+qRKJEpBEmKUgtTISo2xTD+5OCGO0/2DiGOBzr13r/kBXht/rvd1L323rt3ykLFe5vJZ+51qPFMzUUomnHvLMT9kUer3gXD2lTTLnjTPbJrntvIoW0vDjM32IMXYTtBE0FTYMTtAb6bKcLaX4ewsxSTLjvIgeys91MoZpOI7eD+i9GWsbXiOhGrITN6b9jKZFthSHmFbaYjJ2QJR+ch7dr9bg6i0kLLx5B1sGtjDyb272JTfyUBcZDSeIkfKQFQlK+z7eaqoUgr1ous9ndR7OckChdCgzxr5z+3ZXlF6M0VSiozGM5Q0pm9dmasGN3DD1Bquuf74Y6/76MEafUNFVvbNcu+RrazMznDPnq2sjKe5vrye7xXP4s7ZYa7dsZZaNUZVQiUpI2LvNIpj5cSVY6zrnWQkO8Pa/ATj1T6unVzH3nIPSaW5hdDRS6YzFEsxN+wt8O7tj7VgvZ59pIKGHo3q1XIas5aaM0rraVYOznBc/wR9mQqr81MMxCVOyu9iNJ4kDu+RKKXehS/Y/eIBZ966r7R0U3Y3Y0kvVxRP2pcztWeib26C0MGMJmIdcrSaqbCvm/nhldOctfouamnMWLmX2WqOO+4aQfb6/t+PQF+hwtq+SYbiWQCmUuWm6gruqK6kXF1e1aTTglU1Hxqc4dT+nfRGFa4rrefK9EQu33MCd+xase/ah4brHw7MXg7phgdn2TCwl9HCNA8cuI2VmWnWZ8ZDA/WE0XiGkcw02TjZf35ubp9KeJdUpGgiiEdSXYlWlNmwai+nDe+gIDUStXbOVc0Qk5KNUiKv+rBP/R1mPZkqfVGZvUkfV85uZGdlgIvvOJXpvT1QjonqUWd4b9FdW1ZyV3YF2dALby2JKJdypDWBmeV1r1wqtTSmqhn2pH1MpgXGkn5uKK2z0rs7T57b10fg6Xn3HtFI2TgwxtkDd3B8bg/rM+P7gqcIyArkREIjPQuWquFCr5d41Ds3sM4OQscSWN3JWOaCrXqAlY0SqiScntvGQFQC4JrscWg5OjZ6SArd8sa5hBW9Rdb3TXD//tusR7ioTIyyuzrArdOr2Do5SGlH3345Jc3nbC2jbBFlupJndW/B3n1QLbC33MNUOXdE1FFdKlIL784oRehUZl+1u4OxrZilVM3Ql6tS7s/Ql6kwFBetmlBUIQ5VpI5p9a6ksylnDmzjEf3X7utefhfCtsoQd5aG2bFrCNmTazmLeQP5bEqUS1jdP805g1sop1luL61krNLL1uzwodiiwy/s00V1sy2QixP64gqFqApAFWFXMsju2gBJslyyTYJMSpxL6MtVGYqLZCXhjtKInR9jQyTbe7qe5e5yhmotZqY/z4mFMRIihqNZCjJXXdotQEDiFIkVlWV2zt0Ncrka6/smWJuf3NezcdLwWxOJegBfF0qhiJRMlJAloaoxd5RWsKM4yPTeHqIWmW2SgszEQEy1J7YM6SS8tzD1d3HNJ0EopTlKwN6kl12VAXaW+5mZLLTc10eKu70630h2hvXZcUbiaWsULnNtSYB9jcMrGjGR5tlaW8FMmmN3bZDZNEdvVCEfWZWe2cTa3hQi63Di+Nwejs+MUZCEkSix6oAiZIH1mSK9UZVkQLjllFF2zPaz/a4Vy7azCY1Acyk9o7MM9pZY3TfNup4JamnM9/acRSWNmapY5xvjsz3MzuZJKjEscJFLIhT3FrhrNsfO7AA35leTJBGVUgZNIqR87NTjXwwtZhjfM8B0T5V8pkYtP0spVEnLYj1P5qV2TFZXSQvWBW++v7zvJcf36rmTHClba4Nsrw1xTXEDP7zzHswU8/ay5y6XobGyas0kJ6/YzT37t3Nqfjt7kz52V/spxlnL5T4kW3f4pH0JK9ZOksskJGlEkgp7x/uQsdYBaDMVZbhQ5ISeMUbiaaqqjCU9/Hr6JO4qDlEtL6N7qEDPcInTV+9gZd5K3cZqffxm9wbGJvuoTOYXVdKuxZi92sfUdA87p/vJZ2us7ptmODdLLY2pacSeUh937BwhKcdIxYOEfSIglyKZlP7BIoVsjT3aD4fp5ZpHKxHdV+0+VaEqYp12aEw5zVCqZagdQ+3w5qORIv01svka63smWBnPcFNlLVePrWPvjJWKdEJEUY1CO57l1/nOklChnGaYTfNUNENVYyZqvYd7rTp2t5dEDWZKjGYmGY5CI/2G6nv1gqGSxsxohp3JANeV1jNR6+GW6VVMVQsM5YoMZUvMJDl2FftJVRjKlShkqtxroIdCb5WBqEivzFJAyUcxWWJ6BUailD7ZyuyaK7m9vIrPTt6f2nIMogSrO55NOX31Dk4f2EF/XKY3LnPj7Fp+te0EyqUs1b35/XrS6+iBVCGasn2WAMWmxbr5RcUIihGVSsTUQJ5YUqqp7c9YUnqjKtkoBFHH2st2cxZAbVw1xis3XMxoPLWv3cj22hBXzR7P78ePY+zOYaLS4qqNaqycNrKTJ6z8HaOZSdbHU+yQCjfGa8lIuix3edxX4yHrNu+rn19Os1yabmKmwyAKgeFckQ25MQajEgnWGcKNk6vZNdNPWo6XTRVeFVg1MMPDVt4EWM+vk7UCO3cPwu7FBVBgHSdQstYVkzvzaAQ7BoaJ8wlpImjNGv1LMfa2kM0EomxCnE0Y7Z9hRX6WqdkCFY7+DozubtnISj7rNXqqmqFKTDnNUk0iUn//lokg31NlqK/I6twUw1GFcpplx54hkpkO2zWJzj0UJXJs1HxapHIaM5PmmU1zTCcFSmn2qKmRc/dEEBK61M6mFKIqORJSFUpYI7EqEakKM5qlqhluqaxmS2Uleyr9YCCvdQAAIABJREFUbJ4ZoZxkGJvtoVLLMJbpoZCtUallKFayqMJEtkAcKZOVAneUVjCcLXJyYSfD8Qxn5baxNq7t6yUtK7A+M05EyoaVe9mSRNRmM/sCg6NZ2psgPQlRrGQyCdlsQiXNsKU4Qk0jKknM7mI/xdm8vfRxGVW9O+qINeYtxDUG4hIDkVXpsxdHH3mNJ5eaZtVeYJpJyRWqZDIpI32zrOqZ5uT+3ft1XjKrMbeU13DF2PHsmu5b1HmrWYWBKrlCjTX5SQpRlUQjdqW9bKmOcNXEenbODlBbTgFB1ur09/eWWZ/fy0hmmqm0wGySJxsvXDlVI9CslQ4OZkvWsYpYdb7JtMDu2T4mpgvLpxv+kPnUm60wmplirNbPraWVbC8NktaWtq2nKGglIlHsnVEhl9prUx1IY6Wvv0whWyMSpZRk7WHfdU4gE6cMZEoMxKV91cYrGlNKc4xVepmaKVArZ5b9b09HBLLZGj3ZKvlQhTmSlDiTkGRiQu86LadLc9Z5WtRbI1+oUhFIZ5bfezSX0mwtx3itjwgNnRcpaSwUM1Y75Eh2t0QOmlG0kJAvVOmPS/u6iJ3VDDOaY2/SS0mz3FVdwXRS4Me7TuW27atIKhGUrC5pvZhqBuai+7Bvi2HYHlnBddEGpCdh5aopRnpmedGGyygU7qAg1u10QYQzcuNszO5ldn2em1as4dJtp7BnZuTozikQ6F01yz1X76A3U2E0N00xzXH12Dq2TgwxOdlDOpXdV6wscHRv79EuUnqyVQZzRUYzk6zNTNm7YkJvXtZj3OFeyUNHexNO3LCbkcIM547cwob/n703660zydP8fhHx7ue8Z+EuSkwp18rMqmzX1NIr3J7u9hiGgQFmPsBgfOF7+wv4Sxi+MubG8IVh2DcDe+zxuKZ6ne6uqe5auzJTqcrUTnE75FnfPSJ8EedQSyrXkiiK5AMIogSSh4wTb8R/ef7PEwxYUxOWlJsT6UknW369brGnU/764DU++WgDob8er9zGmm9efcCleMx7rXssqSlDnbBd9fnJ9Co/++QVmHpnqrBgY02Ylmz1hnwv+YSeyjjUbcYm4k/Dtxh+UdvNc5SWKKm4Eh5x2TsilRW1hcOmzcFChv8sBAfi4SD5UpjxZrDDj/Vr/PJok8NZ8qXpO18a9mF36sn/v8DjEJHmzeV9Eq/moGgxrcKzN4d3AoiDmq3okBVvDLhuVGZDdw7OujT7MZiLjgk4CnMrrFiOZiTSyZpHoiaJKoyWNIV8qrCJlRbZqYniiiSsaYclh7OEyfBLdv3PIwwMiha3g2U2oyFr3phEVqSqcHN66nRT7E8miVIWGWnCYCGXbY+lnAvjMzExMxNyv+wzrBMGswSdeaDFV5Y0FDiH40kWYixcLy45+XQ1Zl1Vc9EJFz1s+CMK69MKKgbP6Xd/7nik8hEFNYlXEUo3BFlqj7z2yUsfU3huLS/wQmElrkoVaFK/oO1VJLLEx5DheMGZOfsHrphX/LtBwbo/4rJ3xJIsHvOFczLaPhMdk9X+V3J4t551cv5zOXM/qVmNpiwFMyrrcajb7NRd7lVLbOddbCkfqiydBQiQoSZNSpZCJyKzEDH4srDKEsU17bgknRe/FnK/tfWwjUSepaTzkUFyhXUm7lqhzXM6N09zZHCaICyRaoiV6x5nte+G9S/wlaCkIZUFLVnNbTZwnSjrn1nD7N8EjVYU2qe2roASyZo0KmmMZDp+/I5ezKDjWaKoJgndzLO8aC1/Kdi5si5AS5ZoKymsTyTrU0+xP5EkSiQNb27ucTkZseUPaImGfRMzMC0GTZub5dqxlOFsHGGL+WDt1+TnikpSDmJKGfG/jH+H/9X/Lr+9dZt/ufYf6MmcLa+mJSTvBTu85h/wH1uvckeuH3vFvEwwoWHj2oD1ZEriucPxQd7h5mCJuvKop4Hj2l+owpwK2LQh6easdab83tInrHsjNrwRkTDcbVpcLze5k/fPlMrh0yCUoRMUdP2cVOa0RE0gXAIFUFjDxApulBvcKZeYFuGXT6CUxVvN6bYLluKMzdaI1CvYig5RWN7PNvmb+nVuDFfZGXQdtfUMFRis7xLIzZURf7Rxg1fCAUtzZdKhTthpuhTNFx/9Im747uW7XEsGvBfdZUXV1NYp8+mXhK/+ZWEFTrwgcMHlQLeY6AhtJPYluxPOGoS0tLyKUDYMZgmjcYLJvDNDu33umCvNdcOCN8MdUlmQSufHM9Exe3WH6kucB+cJohEcHrWY5iHvdPrQgmv+Af/s8s+5VSzzb6bfgvzhTJ5tN7x2dY/UL+kEOaHUPMg7HGQtqvqCIvlFEMIVr7oqZ9M7wuCSKGMl4pQPiZ7IkyN9w1ZryGY0pCVLJFDhBskmJuaoSdgr28eykb/p9SwMiDlNwmaKmpCPOyvsL3VQngVqpBAsSUkXTS/IQYI1LxknXQDKcrk94q32HlMdMmtCZnVANoqhkojqwjz0NEEGml4rZzWesukPWVVjWsf01pDdusO0Do/9Zc4yJBZfaNQj/JGF35sGaiuZ6IhhnXz5boAAFLSTkkvpmGutAe8m20hhURgK63NYJTzIuuwN29j98FR6T3xtLKR5laUf5bwTb7OspkTCUCOYmZBRk1DrL+7qSc9yLRnwRrQ7p1kKDJbiLND3noRwXUvpub1Y2IcV6Au8ePhSI4WhrD1Moc58kelZws4NiiNV05M5iWjwWZyxjg105gyzf1NYgSk8SiuYzVWgU1nwbnSfUNb8W/+dx0ZBZah5LR2wGkyOxTuOqpiqUeiLDt8XYtGxC6Xz5NJIMO7fT3punjacSBKllGE1mLDiTZ2vkPX4SX6Nvxtd47BMuDfqUlUeFM/v0trZ7/I/8ke81j3gv934AZuqwhcCheC3Wnd5/80NDrOY6f3OS+EobXo1Vy8P6IQFb7X36Ho5vxhd5pODZarSh9K158XF4fjiIeby3cqy0pvxraUHbIYjl0DJkpn1mFmPn2ZX+fcP3mI0i89859DMfH66fYUPgnXurvRZCye8m2zzdviASNSksqKwiiVvShl5BF7zmBLkU79nW7N++YhelPNeb5vL4RE9lbGkptyuVvk3u99iVEaMZjFV5aFn/tlKoHBdqN7lMWvtKb+7dJNr/j4tUaMEjLTH345f5/pwjdG49dnfY0459TxN18tI5WIQ3fnxGcTZTDCEPS7g1dYjUSWb7REHqk12FIM4+4IvpxKChzTSWrni4Bk/H58VrLLQrfGjhldaC3Nn56OpMcf2MBf+UI9DzI1zrRYMq5jMemgEqcy5Fuzzn7/+Efcu9fCEJlCatXDC99o3iWTNULcojc+0DhketbCVuojDPg8CPGGIVe38MkXD0MTcqla4Uy6f+vnHE0ui1oIxq94YYyUTE/DLyRV++uAyRR5gDwOEFs+3PX8Q8uBgjf3NNvdXevTkHqlwxrzvRXepL3v8bLLFD/feQVSnP0BodQv+xdbf0lMZMxOQmZDdaUp5tw18gdnoBU4UVgChxgs1l9MR301vs6ymLKsZCsvQxBTW51fjS+zcW4JGIM94kCBzSXWvRelbfpKFRHHFcD1G9iw9NeOydwRATzmvnjioGX0BOVq1av751s95NdzjFe+QriypkdRW8kFxmY/ubMDYcxeaPZvPiPUM316/z+90PuHt8AFXPbd+Ciisx/tH62xvL0H5OWpzygks+L6ez1CUSCza2rkBujyTCpKLiqeZz+tGouFKMsSThnt+35kVw5n7vV8GyHm32mh1Mdv7VSCh3c1Zbc+4Fh3QlQJfSBQCZQ2+0ESyRp7t6+arw+KK6VIwbUJmNiBAk8qKVFb81yt/ibGSRNbHTBJw/qafNEsMmjZF4yOOgpeL3fSCoKQhlA2RrImEprYe96olHpRdTCNPNXn8ZOh80pLKwmXpJqGyiv2yTZEHzmPkBLN0awSZCZlZj8Q2hFKSyopN/4hb/jKnvTRt2hqVNFzujtjwh/hotus+B02b8sIo79RhMXCa9jNW2zPeTPfY8BytVc2jsZ2my37T4ahMnHLieaKqGKgLD2MFN4arNEZxKRrxO+nHriola5bElLd6+0yuhdg5zdFagbUc/xvgUm/MJf+InsyQwlAj+aRe4XpxiZ+Pr2BriXgJ5x6/DKyy2MDJ6q4EU1a9CYksUUANZFYwNhF55UP9+XvM+gbZakjjYn6p1Shh3bzaWR0QEqACTZyU9PycnsrQSJZ917HrL02ZBDHGCuw8CbdagrAo3yCVebg0Vrj9CZhKORGESj7myXeBLw8hOKbjXuArQoASFl86I/dFArVAYXwyHVzQ+T4DwsKkCvmkWqOnMjYYucRTaJRoSIQmemTpJAYfjbrInL48BARSH981vjD4osEX2nk3nvK1PJlOlDSseo669Mtii4M65e6w5zpQJxzUGCsY6Db7ukVPjvBRbKiaVrjNfpOCOr1vmJWwcmnEH1z6hLfjB7wXHDA0Hv/feImbs2WK/Oyrur1MWCRQItb8k63r/HH3fVbVhFVZYnBVq4n1+UW2xa9nq+yMUkQpz5XErNACxj5GeOwehezIZaKVHPm65VIw4lvRXba8Gf/N2p/zL1cfHlcawcTEFMY/rlJ3ZMGWN0RiyaxHZnx+MPwmP7j5FlXhI4qzu7Y2sAT9gm4755vJfd4OdkmlxheCwlh2dIvtps8sD5G5+twzV7YaLq2MuNY5ZNUbuwKYsEieM1vgBcIqS6+Tsd6e8Eayy6Y3OvZum4UBa1cnTHRErn1yHZBrn3Ed4QnN2+kuK/4UjaA2HrVV1FaRa58b0zWGRcz2oIstohf9a75cEK6LL4UllPNq/ykPqE4joqCmF+Zzhc2HZ6gSmomJGDYJzfNSoDwDGMwS/nL4FlfiI3679TE9mbEkM1pSEApFJLx5l97gW5cM+KY59cH/aULk1XRVTkuWJMLSEk7iPFbVqWdRn0wnSlhXzcRSGp9xE1E16oVV3EvjTH31/J3xEYTCOjlFOXeZPo3vmrC0gopXwkM2/BGRECgs4yZiULROPXf0TGIxyA/HNLFjeBaRNIRJzUY44rIakcgGXzBXOZNkJmRQt9jP29SVdy5jBJfYCNDOoqCuFVLYY6pJIhp6snosgDfAxGRUzKllgD+X8K6R7OgOQ91iO+9QZQG2kmebly4tUViThiXJXM58sV41gomJmOj4uIvyNNiFHLyv6UU5Hb84rgxKmFewz+4G1UbQGLeffAyRaFzHWBgu+UP6ns9UR2QmoDA+Hd8lUdeiA9a8MZVVThbdKjITUlifcRPjCc1hlDCLHG1dnCUp/ecIExgIDHFSksgKg0BKQ6Psp8/aCzwVVlh8+XDeZAFtHT030yHjOrqIHT4HTaMY1RE9/6EanxIublQIJNJdYtY58Br78E66wGfDSsCzEBhSr6StimP2RCQaElnS8Qr8oKGIfcRCZfqUPffPNYla+LSEvruMAB5UXe5lPerqxUhqWiMY6ZiBblN4R9Ro9PxdiYQbwKwS5ToCp2guxUrnffNKesgftz4glTWJ8Cis5OcHl9nd7UKuzmyl+LTChAbVrQDQw+Axvr7sVfzzd37GteiA340/Zl3VxybnE+vxy/Iy23WPH++8wtFeCrU87WzSE0EY1vx26xOu+QdsqopEKhQeiykeg0FjSWXjAgELE+NTWI99nbLXpPzP936fe4MeVeYjZp5T7DyjXSgAGTd8c3WHreSIDW9EOPcnz6xlR7f5aXaN2/kyTa2eyi+3EmyrQYaaK8tDvt+/zaVgyIaakkpNJARSCPx5Z0AKw6kmqn9FiEZwdJAyniS8kR5Qt91ec4POrggihTlW7VO4NQjQdGVJ9MjmKqxkZEIqFBveiLGJ2YgnfJCuM5glTO91LhKpL4KA/pUR/2TrOkvejDfCXSYmYrU3ZadRmJmHzC7o618ICVfaQ/6T9C4b3hBwCVRpG4ZG8v70Eu8frJNPw3NZwPtCWKhKnwezDqlfksqCJVkcn4ePTpbWaGprGZuIgW5T6Yv9+XmwrYb1zSEryYx/3PuQb4f36EpNVwYoUfO78ScMwh2mr4XcWlvmxsEK2W7LFaJOUWz+fDOZeZVezKvKxkpmTcikjjAvqn1sHQ+4MD41EmPNMdNaCoPnaSrPukGC04S5TGnPz7niNfhC4QuFBiZ5iJh4Z7vSflqhLHHskqjpxH8ssAyjiv80vc7r/oBVZQiForSGwloKq9hvUnbKLuNpjJxc+HQATqlHGS57R2yqiq4M8IVCIlDCnRm1damoj8YIQ22cqaGeU3Uf1H3uHvTQD5JzU1SQynI5HnIlOKIjXDXPiUBAZkJ2yi6DMsFq8fTcR1hEYPDDhuVoxpXAUfkc5188NkuhTlsp8BlAGAG5QteCYR1TW4lGIIVBYY4TpZqK2kp8YUjnc2I+AilcwKQQFFajREFtJco3zExIlgTURgErTLz0VFZUTxOsgLX2lD9Jf0XwiEl0GpQchg1FpU4vY+SUIfULNrwRqaxwEjOgsZTWY1jFTLPQzYu+2B/z1MI0gqx0FF5XVDE8uVraWmprKObnbWaC52fSfUYgfMOVdMiVZMg1f591ZYiEhy8UbWDTq0nMmPeSe3S9nP28RSZbWOypMoZ+vpGbEQg7d362PpkJ+WSyzL1BD/2CzPKEhCVv5ma0RIMvPGqrMbjkqmkUNPMy7imB9SyiXxHHFZfD4XFAU1uNsT7GyGdDb/g8atoFHoPpNATtim475x+t3kMJy43OKpMyPHbefqN3wJqakAgNCIy1zIxlZHxuVBv82cE32M9b6PzCOBLALlW0uznfXN1hSRWuAyXEYwmUtnOVLgyZrSms5cOqz/vlZe6XfX52dIVhHlNPwnOxpiY04Ft6acab8S6X/UOS+fxIYQWZ8bhRbvCj3auMZ9Fn20hI6PenbHVGfDN9wOvB3lyZTzxGW1Fw5ox2AXfWaRBW8pPtK/z35T8jUjXdoCCQDRvhmERW3C977BSd4y/zhGEtmpDIimGTMKxiPKkJpSaUDVvRIW1V4AvNd9NbrIdjAqkZlRG7272L4skTsL4l2pjRbTmbgkjWFMbnULcZ6DbWCjxP0+5n0HfCMlpLdCOpRyEyPw9P/VeAtCz7M7b8AaloAMXIVNxo2tyqVngwSaknIVx0Rj8TNvcY2Ra7SQqAf6ziaSlpqNHsasNPiivsNF1+ePA2O9OUwWH7Iob6HHiB5tvde7wa7rOhMiLh2CYGQ41mZiy1VU7kJ5C81dunuOwxzSLqvdNjA/NcT/DFrEOjnWTs2EQ8GHaoBtELWwAhLH1vxrKaEgrm7Vjn3l1bz3GDT1GWCy6JWu7NWG9PuBIcHg8y1mgqFOYZJTx2blQKToTror3/GRAQpiVvre9zrTXgv+r9Al803GhtMDERxkq0lVwJBqyqnEg8lNMurGRgEm6Wq3yws041CxD5RdsfAd1exh9s3uSd1jY9CZHw8FDHCdQCBjOn8VlmRnKj2uBvh69xd9Jj++YKsjxHtMjA4CUNq60Zb4fbrMqMZN4hqY1kaGI+LlY5uNdD5p8ta26V5dXeIb/Tv8m70X2uemMiAaFQ+PNDQT3iengWOf9Cu7m88m6b6/famMjgd0s8X7PUzgi9hvuHXcrDGAyIWoKyyH7lePuTEDn2MKFBtmv8sOFblx5wNTnk3WSbb0d3eDe6z7fie9ytl/hXkz+guUiiHkI4ZchvX7rP97q3uRIMiERNRshO0+WgTjEIfKVZa0+52j6kMW5eZVqHXC824CKJehwCVvwpW15GMn9+J1bwYbnJrWKF0SRBTi/un8+DzCXkkkEvAY5DJPTcO68yhlt1nz8dvc2DvMs/3LyMGPqnKoY8jQijmt9r3eCaN2JFzZlV81k919Vz9iTLakokK95rR3jC8OvxCrcOX1wO8SRO5AQ3VlBbD2MlShkXUbrc5cQhhCUSFb7Qc8qLC8hm1qOwvqO76Lks0GmBAE9pAtmgMNTWzXFlRlMY/yupDlvPYufGr35S4XkPW25SWqR0/65rzyVni6+zYI381LkgAKMFJvNc5/FJ+WQxf01p3RChslBLN3NmeWkPmiBoWI8mrAUTejLDF5pN/4iJiY8/Z1WN8YULPg1gsByamFvVKttlj6ZWrgJ4irqeLxJCWDypUfNnUlvrnMztwwUyc7+i0jbs6JBD3eZGvs7tcd+ZFJ+yAsjzhvDd4H0vzAnQBI/M5tRWUlifxnx2kGSVOw9k3LAWTVn3RqSyON638HAGrbZwaBR3mx4HdRvOMn3YuqSqKV1h7ZDEUb0L3+2x+YydRaAL5bZo5WSkRCMwpaKygjvjPtM6JFY114J9tJVOLEVW+L6mDqzrgJ0nW4MnIZyIhGg1+GFD1gR8kq9yv+zxC/UKUx2yU3TImoDDLKasXdjSViVaSTypiVTD3vKUSRjTzPyLxOARLNRLa2uZmIrtJuXH41e5n3XR5cUc9RfBxAYRN6y2ZwTzyzqzFm1hV8fs6ZTr5SV+PV5lmEdOxOgc3UFfF1pL9psOkagZGI3CsqM77DcdKutUThfFOo3gerbOr8crDGbJqRpdOZEkygKzuVpR4DWIuMFm3osZrhWWlqxIRX0cJGQW9nXLVbpqhTyFre3Ia2j7Jb7Q1NYws4ZD47GvO9ivwL21sWb10oilOOOfbvyCN4MdAJQwaCsxuFmAiXYGsAsUxuegSdFzI0pwami+0Nwulvjb7WvkhU89jBD5I8mXstBuUL6h353Ri3PuH3UpdlvYlzh4WEpyvt+5yWX/kE0vJxKCVbWHtgvlHo6paADF3Kj0RrXBX43e5OZ4GTP1nXfMxYELcDw7CVBY8G1NAvjiYUBUW01ma0bG8uP8NW4VK/z1zqvs3+6fuoHT5w4BUavijaUD3mjtk8qKcG4grq2lsB5DnZBr/zO/hY0MS5dGLCU5323f4rfC+3RlTeuR7t+iYFMDN+oN/mb6Btcn665jf4YhKoFtfKywFCKYV4wepzoLA0w9rHjodygaATMPMsvBZIl92ad43edKcEiqClaVM57vJTlZGrq7MD/ba/lZsBKQFtmp+UdX7xJIzc3xEp8cLZHNIvTUe7ygGRiEMuieZCMczYuhFo3gvfQ+tVX8X/e+xf5HKxfn6iOQuA5UYRR/PXuTf3/9G9iZh6guUqjPhYBkdcZ7Gw94p71DKt2w/L4OmJiIv5q9xd8dXWV72mH/fg9RSeR5uoN+A9SVxy+yLe76SxzUKbn2+fuDLR7s9BGeIYorPGVYamXEXs2twRL5fnLqFE5PnEsgBe4yeoFroBGYR6ZSKyup55nvae0KOMlng0ZQWMPIKG7VS9yrlh7rGAHH/hoI+/ACUharLCrW9KOclcjNhS2rGcW8C/ep18QQzGWmK+lkp80jF9rCHA3go9YaIxkxrDyMUA9f1zeEiau69uKcfpgxCBJy5aTkX9bZK19pemo299BZDJe74ryPG8TXWIy11FhKCzPrsd+k7OYp4yI8d12TL4K1Yu6x41EjqK3FCOOkjR+plxrcMzzVEcM6Ia98ZHU+k1GlDG3fSUD7wqBwybu2LrDUyPlZ9xmQllZQ0w1yUpUfS/DLR6h7tTVM5vNVO3WXB0WHYRGfi/U+lt//ip/zpGz/uAi5Vy2x4k9YVlMUlnZQEsY1RSPPLw1NWaznZPVT3yn4lrVHkQdubvpRBb550976HEvRIzShrFEYeipDYkjDkj1lHTPilN7nJ4mFEIy2gsIqpjrE5urC/PlLIvQbLkdD1v3R8TxUYT1mNmCvStnPW0zz8NQpOp92GCN4UHYZNzGHVeI6zZMWTD2MZ8mNQHoGKSxF4FEWvlM/PmX3zsmY7QpLKnMAjMU5uL+ghTBGslv3WFZTEjEiUVBaxUC3GTfR6aLxPQJPGDyp2W86XK8n/Pn0bf717feY5SFm7D/Wkre+hXbtkqnabbrOyoxX+4f0w4zXk318ofmouMSv8iv8dLjFJ4Plx2iBC/XEzf6Id7q7hLKm72eEsmbLPyRVOT2ZkcqKLX/Aij8hMwGjJiEzwZzCqfCFpuvlSNyQoEFQaY+8DKhKD3sUvHQHjxUQezWXvSN6spwnUG5PK8AXch70G0oMM2P5+/Iy96plfrD7DjfurruW/0v2ez9v5GXAnVkfX2iGSQCyIrLm2IdjkUhJXECwV6Xcz7qUpXfqDtaTgBUQBzWvxEfugsc+Nrf0ZSB8w0ZrzFZ8NBdBsUQLGp+1zKwhs4Ifzt7iTrnMjwbXuPVgGVOpiyr2V8DRXsr/UXybjd6Ef7FV0FMZ/8XaBxwutfh3999mMF4+l3tYdCuW+zNCr2G/aFNqj9EowUz9T5+P1nUHaRQH0xYfzjZY8me8Fu8TyIZVb0wkai4lIz7urmIrCXN7g3MLYfFFQyAENZJD3SYzwamNc04j1tpT/rj7Pstyho8Tbt7XHXbqLh+MNti+v+TsSc54Z/5Zw4x9/uLGGy5ONa4CbQvlOnkG0D5aWoYz36lTNwJCg5iPjZyW8/JEkighLIHQ+GLuOm5f4AJYwURHTExMzRiNpUIxMyGlOb1Dvgv368wE7OmUG7M1jra7iFIin7gkrLL4YYMQ0EiFNYKNdML3+rdJZMW6P6K2ip/NXmGvSLmxt0p1r/XU172rBS2/ouMXeNIgcZSrnszoyZIlqenJhpa4+ZjxaWF9Cusfd7M0gvt1n0Pdph9mxGGFtVDJ4Lmu2/NCIBtSWZEIjRTKyT8/coYqITB2QauSbNd9bhXL7ExSxNC/4Ew/CQu6kUzqiHETkZmQSGhqND5zI8MnoqHcBEyr8MXZJZwCBErT9TJSlaO+xh0upKXrF/T9jEjUBEIcS5kv5qAy43GnXOaj6RoPhh0YhOdHuOMZQWSKqkzYAUabCT2V8Ua4g4oMP0m2OBDL5+9MEOCHDZfSMY2RzOqAvPYxufeZXZJj8Y/S46hMXHEuct2qSNSksqDjlfhhQ42jVJ4pQ7OvASksPgLRROYQAAAgAElEQVRjBYX1qU5xnHPaYAV0goJr3hGR0CghKIxlZkJGOmGYz+1Jztuz+wwgSwmlMzBePKHHf+uHXfxjZpVnsZ7BPdGn55k+safJFw0dWfBq7xApYHCQQnnywY81MNIxe02HJTVF24yf5Nf44eHb3J92XbZ72mDg/qjLpAq5PV2i7ZfcHC45B+enPLyiEdTTeXIyF8m4ubfMYZ7gKU2oNMYKRnlE3SiK8WfLQdfTgOs7a3ie5nq4RiuoUJcMkXTiHOlc2XCBgWkxMyG/yq/wq/ElGqOojHIHeONTasUkj8imc2+KFyAu8nVhJdi0QYWajWiCj/lU4GqsdeIHWA615kbdZ6fp8oP9d7g77DEZJucvWPqSqKcBt+wy0ypgM3ybS8GQ345usq7qY8Nd4DjIL7VHbaSrYp0jWAk2NBAYNtsj3gx3WVXjY1ppjUUDA93mdrnCoGx9iqZsOg1Rp2SjN+a32vfY9I9YUgWhkE4ZyRj2jcfPiivsNl3+5uBVdoYdp0B3sX+/MoQRWCxVFvBng7dYDTf5fucmm/4R73R2GH0jYjiLyR+0TxXf/7nCQpX73D7qo42kKj10I53q4RegngZ8sLNOEDR8OFwj8hre6e6yEY44qFp0WgUTEVJJ/4UIWL1oWM9iY02QVrSko0lqhPPH/ByhmQs4PH7Xj4mERuJmmyfW42a5ysfZKll5ocL33GHn46ihxm9XNJWHrf1TM09/Yp0ohSWSBd/u3qMf5PxV/hrV0WcPPD8vWOPMFA9UyrbsUyifX8y2+MX2JnXpnUqKlWgE08OEmRexI92OMou259OSqFog6sffWp3HHO7Gn/5k+NygSE48molHLSFXloPQ8FFnnSvBIS1RUcgKbcVcRQ0GTZvdpsuPBte4fusS1MJxhZ8IdIV9CeuDypJ0c/qtnK3okEAYJyAxn9mpbXMse4q17JuQfyi2uFUs8+H9Dez+hSv850FOFWaq2K0UP46vcinuz32PBihr8LEsrLGVsNRW0mjXaX3p9tJvAmmRrZogani1NeAb/h4t6cycARa83EPd5naxxLCIEU/Qd+JuwXc273EtGfD9+BO6smRJgo+ixJBZ2G66/IfxmzzIu9zeXkYcBhdKXl8Xc7U/kyk+uL/BraRkPRyz4Y/4Tvs2b8a7/Hj8Kj8cvIOoz0+Qa3OPsUmcYmuuEObL3QuLe6kRMBMdrG842Gyxlk6RWJbiDGOhlPGpqlqfFKxvCdKKfpodj1LUVlFZRXMG7QmeOZ6468M5w2xmJEMTcTNb4eZ4mbJ4OZk0Lx0syFCz3J0xziLy8ekpjpyMOt+8jQwQypqWVzqp8xcAIS09P2fJm+ILjUFSao+m9jC1Op1BrhVQu4q7XWQfzdc4CH+D320h57uoaCucyIW2jmu9r1tMTMwvsy3u5n12J6mT/H1CzeplhpWWVlSxEs/oqux4yBQeykAbYGKcZP6teoWfTa6wm3WclOwZWIOTgK2lM4HUikG3zZY3pLINCOfrJoVFYQilxlMacc4W1ipLmhaspVOuBEe05MNkHhyF1OCEYXxhaAclolNhGokKDFIaXlk64vXWPpeDI1JZ0ZKGhdhxYS1DE7DTdLk9XWKQtbCVOoeh6LOHMIKmVOSE/Hq2ii81oWhIVUGoGvxOSe057zhRna0Vt9L5QDFX5DveULXzZvxad+/i2xhBVXtMq4B2UNENcvLG5zAyGMGnrTfOOgzoRlHWHrX1kELgz0WigrkZ9wU+BwKEWAh66WNvKCUsAZrUL+iFOQ+8Dp9azcU2O1/X0nOHVJZuWKCNJAsMCAnNixePOZEkqjGSoUlIZc6SmkEIgdeQn8SLPwGpLG9FO7wdblNYH20lMx2gZ978DTl9B60wIAr52Czoi/BYEsYlxPDQe8IgGJqIn+TX2Cm7/Ntb75DttxBaPJSKPyuHiYTXegO+273Nm+EOkRBInHoZOB+OGrjVdPm4WudHo9f4q+tvYvOLIfyvApEpju70OWqlfLR8iVf8Q1pi/NC3yAp8AT0/ox/lDLzWaSlKnQx8y3925df8fvpr3g0fsCSd07sSgto6KfKZkShh6fkZr7UhulrjScM30wes+yOuBQdc9Y6IhKEnJXLexarR7OuAG9U6P5le5aM7G244/xR26F9GiFrAxENnHj+xr/CraIOt/pDv9O8Sy4rffuUO4zriH25twuHZqnLbwOB1Kzxf045LAq9h56CLHYS/2X1mAS0oc58jm9Berni1NSD1SyZFSF76lIfxuZKRF41ATz2mIjouYKeyZsMb0fEKTme1+HRBSoOSBl9oEqmoraG2lkTWvB0/oK1K7ox6jEge+zqrFvyzl9fC5TQiTkre7u6yHXQZzyKqwsdOPcQLGAt6FCc2E6WtPDYaTG2BOuHq8cKPwvM1qcqJRMPMhGQ2pNJqLod6ije8ffHnnpV86ofQCDITslN2eVB0KfLAOXyfJYj5wegbur4rBCyk3RfQWAoLhXUGcnfKZXaL9EJK9mtAGKASGE8ybiLGJqKy0xf9Y714zPehCDQbwZgtf0BPNvgifOqnR8KZujJnTYey5o1olw1vyIaasqwsPvJYTbJGYx7xl5o0kVNLOmMdkReNhVmvzhWFCZi2QmrrLCTWwzEtr+TDcI3G912H5mVXlxMcm637QYPnaQKvwZ8rIj2r389qgdHurG2rktLzSKMSISylip7Ni7wssAK0wGjHFgEnda5wktEX+BwIsMLiSeO6w08MbissiSxJVYGnzEPhg3nyZD3jPtbCKVE/+e0fFVZ7GlNn8f14JNy6eMtQwhLKhpZXEQYNxghq+eJFUk6MzldbhRKGy94RlVLEfv3FX/gsf4a0od3PuNo/OvbpuFFtcKtYYXvafdjuv9isT4X1LDbReHFDz88IhKa2Hvu6xS+LK/y/t99xYhFT78zNTZhYEy/ndFs530h22fIHpLKae/FAjSWz8Mtqg72mw/+99x7vb2/QlBdmhr8RrODObImf+teIWjVb3gRYJKyCw6rFYZ6gz8kMiWlp0tUpq+0Z34rvctXLSKVCIo9nxcCxpQJh5vvU9fuVcBXVVZnRkoZECBLxcCbVYMiMprDOEPpH49e4eU5lt08EFkSuMJUk6/oYK+j7GW9FDzBWMrjc4mZrieGwBYPwpX4fTLvBSxqCsKbfcvtxmMXUtXJKfM/odRbq/i2v4tVwj3U/pOMVHNYt/t30bez0fJwTME9Ma4mpFYUNqK2j3y8SqQs8HVa6jimR5o2lA95q73HZP6S05lhUIjPu3PSFJlAaE7rPX1qZEPsNa8mExKtprKSZK8caKzBWUhmFnitRZpVPXgYUg9h1+ufdWBtYCIz7uHEZlajOGR31Kai1YljHeMLwzdUdpk3IP5SbkL/Yjv3JdaLmR2VP5mgEoXeyvFwVatbSKZdi5yUhheWgTrmf95iVwUUC9UWQbrAvCGtC2SAxVPNB1b2qw2yQIKdndG7Ct6ykM9aSCSvemJ7KnOw2brbRAIVV3K/73C/73B720Tvx2VyLk4SBSR2yW3WYxDHgkihjLdoKZjogr3ysludirUWguZROuNIasuGN6EkPf07DezSRUrhEqicrWqIhEppUOuqpLyQKR/9bfG1tXaW1xnVSD5s2D7KOM4Q+zd35lxyiEU5JVSs0kkRWXPMPUFhebx/QGEVeBpQ8vdP4UkCACAztVkHoN7SDktooqkrRFP6zV8MVlsir6amMnspIVcGu1+VP/Tepnu0rnXoI47pzzp/RQb70bc3nDGlBWlRgWAunvBru05MZ2jq7h9pKqvmElBQGX2lQFj9quNo9oh/kvJ7ss+JP3LpbiUYcf5yZgNoo9quU3SJlP2uxMw6xVs7ZRgI8g4oarBEY6eYFadSpEVJ4UTBGkGuftlexlRwxa0Le9zdc1+4Fxu4nlkQpzLFzNkDqF5i0gUY6utPzWAQBJjLgGdb7E76zdJe1YExhfSZNzM9Hl/noYI1sHL1wqtxphVVzB9lWw6WVEUtxRqIqhjrhQd3ndrHMx+MV96CfUahQ82Z3nyvxERveiJZoUMLR9zKrGJqQnabHnw6+we3REqNRci6C+ucOCf0w40rouseLREFjKa3HbpYyGcXY4owm70/ACxu+vXSPV8IBy7JE4ipwi+RpkQwpIYiwTs1QaHw4NoT25wGALxQSgZkfvLU17OiQfZ3yy+llbh0sURWnRwHpLKNpFKM6ZuTFGCsJRMOSN2M5nOF7S5Qv+gf8DZG0S76xssdRkXBv2KOuFfUscIp8zyqJkpakU7CaTrmaHNJTGeAordoKoqCmDKzznjnDd9XTYKykshY9V+W7oPN9DiSI0OD5DbGqiGSNmltGSByVL0DTUxlKWLbaRwzWEnpxwSutI/pexro/cr59WNQ8aV14pC7eg6FOGLVbHDYtrnfWKbRHY50VTOJVpF7JTAfsZil57bP7oPcpxeXzAqssSIjDikvRmERWdL2MTIW8uj5gJ06ZjWLEC1D7hhOUOPcfNdsF+kFO1C0pcx9bBs8libECRNIQRDVv9A74k877SAyF9dmpe3x0sEZ+J71IoD4PyrW343bJ91bvsOZPiGTNSLf45eQyv9y7RJ4HZ9rbxA8avt+5yVYwYMObkAhNjThOoD6u1rhTrfDzu1cwexcJ+bPEcjjjtXCPJZWhhAIrMWgK6zGYJYij53N2nEbEUc0fpR+w6Y1Ykk5IQs/lzBfJJSwSJohYiMB8OnkCUEI64zwcRfJuvcztaoUPj9aoHrRe/lmclwS6kRyVCV3fUd18Yeh7M9bDMXFQMxEvfh7268IKWE2n/OP+df7i6C0++viSM4h/1swPCZe6Y36rd5934m2W5zRWLQuUMLTCimGooZLnLomqrTr2clQXdJvPhVUWL9DEYU2iKnzRfKp75wuXRLVkyTfbD2iMYinIeDfZpiVLevOZ6ZaoSOZJWCI0voCWcDOotT2Ym5lbJj03t2YQ6MXZjGVgYv4ue40HVZd/PX4PPT6HSZTAxaDKkoYVV4IjElnSUxnaF5hVwUGvzV/cf53RsP9COlIn14kSrhPlz711loIZaVKgtaARPs/KNWghoyraDcoz9Lsz0rDkUjRCYpiYmA+KTfaqlLK4MEr7IthIE3cLVtIZl4IRXZVRW4/aKqZ1SJ4HNJU6m+s4H/BUypCqgpaojg12jXWGukOT8PPZK9wveujqlErkv6yYD5ImssTHIPGpqSmspbA+xjynDvZphABPaTfQLBqkcLNQ+imtIilcgCrF4kIWx8qGT8LMvbcKa9mu+3ySr5I9p6LWBR7HosIahA3L4Yyu5wL/wipuFSt8OFlnnL2cRRmr7LFZ6XoyIZElntRghPvzjH4nqyw2MohIsxzNWAsmpLJAzl+gsIraem42pZGf8ks7T3g0SL/A0yG0QNfSScMbR8EDR8YxAhLZoK2bLdNCcCU4JGsHdFXOhjd0yZMsnZz8/I+PJRKOIbA4k+W8AKZxe7Swik+qNYY6QSNdfKUjPs5WOSpP4dyvAJNoZNxgtcSW0s1ulfKZFN+sBDyLVRaV1vhBw0ZrTFfNiGRNJCtq69IX84Kf6RNNbaUwpNJNR70dP2C4kvCBWmf7IH4mtBGrLNaz+P2Sf/rWL7kcDlnxxrRkhRKuA/VBscn/9vF3yGYhZuKfORGEZ43O8oz/8uoHrPtjvhPfQgrDh+UmozrmIG/RHEZnliJhlXuI46BmVY1ZVTNSaQiEI+FqLNeLTf7PG9+izgJEdsoOupcdAvp+xpqa0JILypphYhRDk2DOybzOMZ3Bb9hQM5aUIhIPj27zxKC4QuALdZw4Oe29R7pPT6C2hpFR/Gj0Kh8M1piM45cycH+pIHDBf2C43B3x/c5NlrwpUhiGJuZPd95k5/aym5t6Cd8LGxq+/+Ytvpk+4EpwyLI3JVa1m/t4hh1OGxs2rhyyHGf8Qe9j3o3u0ZM5kTAUVlJYj7GJyCr/3Kukapy4QW0v7qnPgqgFduSTN5Jhk7hinZX4QhAh6MrFneM28aa6ze9Ht1HCiaCque3JQ4K5gDmVWiGorcFgqbFU1jIyihvVGjtNl//93ne5f9DDaIFZFKb1I8ISJ74an4G52ubG1iF/cukj7uR9PhhskJW+s7d5BurM1jfITk0U1Xzv8h3eau3xarjP6/7e8efMbEBhfIZ1TK1f3J4+kSTKGMlQJySiZFWWRFLQUxmrwYS7QQ/r2S8v5bqQSxWAdFKUx1AWfEsrKbkWDdgKBiSiJBCaoUnYbzrslF2XQE39M01B+02xkIRvRyVXgiNWvTGpLACX+RfGp9LKreFLeMl/KUhAWTzlTAp9YY5N9/R8yHSiI+rcd+aYF146zwaPSMqHoiGRNT4uWaixDEzCUJ+fJGqxHp40+Nhjat5nYeEZtfh4gacnUJqZdR36YRUzy0NsfT6EOo6lhKWdB/fP8Cx7wnBzcZ7OYyqstMi4QfmaNCjoKad4OtQJh7rNJI9eXquIudzzRjTm1XCPjirw0ahnmA0uZnVl1LAcZ6xHE7pqRks4+YjMKmbWY6fpsVv3qGvv7N5TT8MiTlL2MYnu6gvOjnMP6wrCthFMm4CJjh9bMx/1WFffl4ru/OPHFVKdZYRLmqAy7u+ZkZi50ESFi4vv1kvsVR0Gs4Rm4iMaefptJQR0gpJXw32MFewlKZ6KyKMIM1cZFFY89Mr6rGfvSXl4MT8jQ0OcVC7+jIa8Gu6zqsYkssZYQYVjoeTaZ1zFNM0ZT6JmhzH/w0d/xFp7yn/3yg/4VjDgmn9AK3Ujs7eXl6gKDzsOvtCl3bQb/HZFK654tT8gUg1mfmN1/ZyOV7AWjPlGuI0ShveLK+zWHf5htMmvByuUhY+ZuATqQnnq6bDKIpcrorji3f4ub4Y7JLIkEpqZ9bhZrvLxdIVp/hKrRn0J2FgTtkvWkykdUZIIe1xp2jcht+oV7hV9qJxz9rm6pJ8jTKLprE1ZmUt5byiNj6S2mg/rFv9q9w95kHUpp+G56CTb0CDjhl6Yo+ZHlrafLul/FXkNPZ+FOjAVf5lf5Wa5yq3DJWdKeg6KASY04Ftk1BC3KrSWFAfxM+lWHMskCx5KE3dr0l5G6Df0o5zQa1iPJrS8kkvBCIBPyjX+YvAmB3mL2TB+Kfe2VRYbWFTsvMxe8Q/xReMG8uWzU+RVKyWvrR+wGk/5ne5NumrGmjehQvFxtcbtcoV7ZZ8f777CNA8pDqOXcj2/LkxkCPoF/TRj0z+iJQWHjQvaZ0340IjoAk+HFnww2GBcxYRrNW96H6GEmN//Dzv7C5EOg5lXSpxhuUZzoDWDeZzwZ6N3GFYx96Y9ZpUTQLBWoI2kqj20FtTj0FminPK41ErH0Am9hlTl/FZyl7fjbQobcOfSMrn22a/aDKuE++MOh/d7T7UQsp7Fhq4bf2njiNV4Rtsv6fgFLVVyOTwikRWvB7vz7rKjR06sz3bTZ6fu8td7r7K733V+nC8o/joZYYlMcbTdZdKJ2dns8m4woCcrUnnIneiAXjtjJGLymc/nNi2Fk9nupTmb7TF/svIhqcwx8+Nx1RuzqibHw5MzG7Bbd/hktsKvByvkd1I3K3ASv/TLDAlJq2A9nbIZDVlSUwIMEouxkmEdc5C3qaszPOgoQPqaVlzSD7PjLtRi70xMxG7dY1RHc6PmF/nDni2IwLDVG3I5cVLebeEfCyfsNx0+PFxnNI1d8noe4Llh58R7XKR5ISrxZaGteawbZbBMjOKjYoM7+RL57AwaZX8WlEWEmjCuudQdk9c+94+ekSHr3FjWfeyqsV5Us9Ub0gtyXm/t01YF696Ijiqo5vLHB3Wb63trlJnrbL+UkIDn1M26XkZvIfCAcB2RZxEfCkjbOb+7cpM1f8w3w/tEoqZCUVvFbt3l/ekl7kz6HNztIQt5/u58z7DUmbGeTOmpGaFwUtsTE1OaM3xvPyMIIxjPXFdlr99B48R3FgnU8Tlqj8XjQRi0tcfz0jPrsa9TbpZr/N3eFpMsohjEn3nGvjR7dN5N94QmEJqemrDljQGYxR61lXxcr3KvWuZv1asc7nWwxiWHjzWjpbvr/bjm3f4u77QesOk7BeRElvRkNddRcGvzaIg11hEHTcpg1EIMghfKnDiZp8kKRONUiHbrLttNTCQafGGIRMVqMkMKS34Yu0+ft+ptYAg6Jb6v6SU5Lb9iNZ5yKRqxFox5M9ghkg9Ne50Of8hO0+XvZ9cY1gkfHK0zyqMLGfOvAi2YjmLK0gdeI9MBXS/nleCAzIRcH66zPejSZN4Ly/6fOyyYzGNIi4/8VX6Yvs2SNyWVOUoYfjh6l58cbrE/aZ+Lyv1JwPpupjFul3wj3WUrOiQVNQbJttZsNym/yLcYjhPqzD8/615JKgIGRYuZkSSiJhJfLsheUEwWF9BYF9RYflwu89PsGttlj58PNpkUISY7e0bZnwkBQlqioOZa+xBjBZ40zKqAqnGGmE0jqSsP20iYeo/Rv21gIa1R3kMPJG0k2ghC31HMpLCUjUdjJa+0j3g92SeRFUveFF9oaqvYazq8n23y4WidYRFTTAMoFeJllZbXAmq3blMdMbM+0dyr7HJ4RHt9Sp6FmOEXs04WeHKto8AFXZf8Ib7Q7DRdCuvzHyevsZ11OSwShnlEnoXn54x4AsKzjuYYj1FYMqP5WfE6Pxi8w51x/0zOMD9TaEE1DRhWiv/Hf5ePs1UuR0N+r32DVBZ0RIkvDLeaPnerZSYmYqfsUltFaTyMlUyakGkdMixiDodtdHlGKP/GxfMf7q3zP+k/5Fr7kD/sXCdVOaksnAS8zFCBpe4qqjc88sZnVgfoRzqgkdfQDzPafsm30ztc9o9IZU4iSxSWYj67p+bFwn3dYqDbfFKt8ucHb/H/t3cnT3Ic1x3Hv5lZWdXr9CwYDDEYAZQomrZJ+WDK4YPto33wwX+njz45wiGFQhEKH2hIpm2SICiC0BDr7NNrLV2VmT5UT2MRSWFIAAN0v08ELh0BxCCnuqpe5stfnuZNykl84c+sV7MS5QGv8IXhQbHKbnyJzWjIhk5p6yk/6RwR61Ue2jXA1HukbKCxmvPh1XtsJUP+sfcZ16NToE6ZscrX7VU83sx3v4rYrTb4PN/m3//wl+RpjB9bdKGlgDoH5YHTmIqY26nl0WCFbjPng/U9fFDcP1wjHCaLW0DN6NRAZngUVvlF8y9YsTmXkjGJrvjlvfcY3V1BPTu7Ir63YD26XXGpO+FvOn9g257S1R6HYrdc5b/Sd/jf/g7lIFmeFROo/6+Z5ihtMfAJbZ1h8Nhv2OP0JBfCU336ZfAc+sDIW/7t+EN+/dW7uKmBUYRyauG/z0/RAaUDK42Cv+rcp2sy/rZ3Bx8UJ1WHgWtyUHTZHa0zzBNOih7qiYSs0HBsX+6z1sj4h43bXI+PmPiEkW+walJ+ZI9pqBKrXH1eDAGtwryfPw+WW8U2R2WXG4fXePTlJniFfsNXtJUHlWu8NZxUbfq+xaapj4V4Oz7i51fu8XDS4/f5W6jn7GQIiePq5T7rzZS/W/+KHycHxMrRUCVD3+Dr6SX2ih6/vP0e1UE9EXt2T17We7OKPNfap+wkp2jlGQXFjeGP+e2d64RFeZl/iZQHNYxARTw6ucwjtYm+VLD/zgqb8YirySltXfCb/p/xyfEVxllCdtys9/Y/2bY2KxpUfYbvQjh7ny/ud7j1oMPtrUtEP3Vcjkd80LzPqq4Pur4aDXnHHvL37S9ws/1fZ4l6AA09nRddXT3FKj+Pei+DZuTrcxDdrEy6VVzhZrrN74eX+eLLbVRuXov75atd13WKO+NLaBV4t7nP2/EhfdcCINaOKHFULY1uVzSaUzY6KVebfbbskFWd0lCzTXpB44JiNLtAi9kmvVvFFT7LdvhqfIkij/FnN4sFuXhfqbMxm2ryLCYE2I3X8UHhiovrP33lAoSpZm/cZWgb9KdNIuXrs7FkNu/FONto36roraRcnkUixzjKAKl37JabfDraZm/SXdpxL53hbrUOnLATZXSfiDB3T9zkylBBgDx4SurNzCe+QR4su9NNTlybO6MNqsLA9CWc2fMmqDS+1BSubgFzs0NutfKUJsKjqKxm1EiItGfYbVFFYb6C1ewUbDYnrCUpyRPdEFAfqOmCpiSqW8uVrxPRQt1ifuw6jFyTm+k2B3mXQdr87s3XbyKn+HK0iVWOD5r3MfE+LmjW7YSyabjXy8nNM3tqzx4qsz0hwSlwCtOqaNspDVNSBsPINRn5BmPXYOQaPMpX6E9bVEUkbdWze2kUObpRTtfk9Zh5y6hKCFNdv+gv0rX2MoWzQlzh8ojd8TrHtsV+sUJiKnbH6wwnDcoiQpX6+QPSFsFsbKoi4vZok4O4y6Bq0osyWnpKSz8+JtyhGbvGU8mQVjk6JsfgZ8FdblZEaXJvGbgWLuh55sHX2QYP0h4H4w6qejFR6i/CKy2iVKH57NaP+Mxe5erVE36+eReAyhuapmRn85RJL+anq0d80H3IJTvi/eQ+bVXSmm1KnQZNEQx5iDhw3bq9LL/CcdnmxuE19h6uQaVQUy2rBC+Ayg1+qsl0zO3Ddv3Z654c84KpScTh3bXH/fwqoJYlwexlU7M2PhO4tnXKP731OVt2wKpJ0coz8JYTFL86+XM+uvkOVAq9pKmaaZrwHyc/Y6d5yr+sfEysylmveD0ejoAHRj4wDZp9t8LBrCf/o9O3GUyb3Dtco8xsfejodBaNtIT3SFVomFr6rRZHZQeHYjMaEStHz0xo6YK1qD53KPUxW80R4zKZb3zuRjk78SlWVTg0x64zf6lPdUIZDFa5+ZkxebBMfMJBucL/DHYYTJvs7m9QjW19L1mw34HKDR9//jYfx9f42U+u8s+bn2CV4687X5O3LNeaJwyrZj3r7A2JrmhH9UtX5iyFj9jPVjjK2jRtyWaz7gD4Otvg62yDm6db7B31CE4Rphf9kLcAAAZXSURBVKZOASuWZ3X62wQbCNbTaRW837zPRjSm79rsVavsTVZQqXmxKZRLRI0Nt7+8MltWmn3o1HyifuEmQp7XwPL5FzugAx/pemxU5NGRR2tPktTv7lVl8F5xtpVX64AxHqVAqYBSgRAUISjK0lBmlnAWshGoJ1dcvcf0dXoHeLVFlKfOkM81/bTJw6xHrB1NU+JRNKMSrQJXGgOuJ0esmgmruu49LYMmRzHyMROfkIaEvbLHyDe4m61zXLQ5HbXQy3iq80t0tnQLfHfoxwI7a1ERL0cdaxpoRCVbdkDX1JvRy2BIQ0IeLIdZBz1Z0EOdn5OvNPt5l0g7JiHGhSnMziyrV+gDZYBjn5D6hAfVGvtlj3v5Og/HPcZ5snStkN+mnsVUVKXhuKwnh6xytPS0Xm1Hz86HqT9btRlWO3o2m8+0auXnM6y5t6Q+ZlIlZNrOi6iWqYuo1MekLmF/usJB2mWUJ1RjW1/TC0j5OlAq5IaDSYdHq6t1mIYaYJRnzU5omel8pjlRFV1TH6FxUrUpfMSkSphUMVY7fFAUPiJ3EZU39CdN/NDWbajSmjZ3FmseGU88ayU9dnV7alpaKaB+AOUUKpNr7VnfNC4hCjhT/6ka9Tt5qOpY8nkypKqvVZg9xlSAMCuySo1OzRsxuXQxFUeAyVGL36XXiKyj08qxxtOOp1jt5rGRI9fkM5+Qe8utbJt+1WJ3vM7+uIP3mmll8F5Tlobg1HJtjBZiEQTqNggfOJy0+STdoWMK9u2QMhj+e3iNo7zNvcO1pX/4h8xw52iD006TL7tv0VZ3scpj8aQh4ti1OXEdfnH6Pg/SHidZi3GWUJWGMrX1rOmSrSL/KdUw5le338NEjlZjShzViQ5KBaz2rCQ5PijSMqbymiSqsNpRuIhxkVC5+jnknK7PLQsKVEDr8NQMq/eaEMBVpm6jdGopVk6Uh/1Hq/zr6EOiyJHYisj4ecx7rCti7fCoer+Yi3g4XiEvI/Ispiqi+f41pahfsAL4LFrIFbwfTIGyHucVn2Y7APx6711Oxi2yQWN52vDFhVJOzVaOQt2Wy+zcqGevv7OFptkXWYXZVL3njXneX9iyjZ4YmBimDc+gMkS2Iu452naKVgEXFHmoZ1QHrsmnw20O0zaHJyv4o6S+eT4zyIv/SBJi8SgPBEU+tezlK7RNvRowdgk3j7YYjlq4sUyQqEqTjep9JEdVl75v0lAlDVXR9032qh73pxv839E2J/12HaozW3Va9rH7NjrT+KyB01A0GnU0+ezBbhJHv51jVKDymhAUWnuMCqR5zHSQzArTP+7P/65wvWX7XehhRDWMKDWk1kMUmGzEtBtTGlFFMyqpgiYtLUUZ0T9tE7IIVamnExGf/Ddf/X/jzaAD2tRtUYfTDpmzPNxfRZ1cfIqZWCJne8m8eq4Qkze5y+nCe99UpXBphIs0+6HLiW1xmLb5pLGND3W/dOkMR6M25TTCLXKsthDLKkA2anDTbBFpT2K3qJxhMGzVs86VvALggMJQWMu9fJ21aMKKzuiajDvFFv/Zf4fTvMXp2ZgtaQDH96ECUGmCf1xEOacYu+a8V59APdOvAr40sxXU5U2AOy8VAKcI1N/1orB1UWoC3iv8bDUv5GY2k33RP/EbaPY+NQgtbnAN53U9nhf9cwmxoF6LIkqNDShDOY4oFaShw/6TD6bwOCBCCighFpPqW8aD3tOfLVA07A911nvuVcTuZJ1IOy7ZMWvRhBvD69y4cx2fR6hcyz6R8wp1YM4fzYjO9iw9O5p69nfEOYTZ875SMNUE7OwQ06fJ9/3704WGApgY+sf1qvXrEAMtxKK68CJq7ix9A76xVU8IseCCzOo/F684SttoFTiyHdpRwYPJKr4wUKn5fVS8AHI9vhwyri+X3EuFeCVenyIKXpvcdyGEeF3pQrN/d519tVYviagAVR1ZLulbQgghxKvxWhVRQggh/oSAxJQLIYQQF0yexEIIIYQQQghxDlJECSGEEEIIIcQ5SBElhBBCCCGEEOcgRZQQQgghhBBCnIMUUUIIIYQQQghxDioEycMVQgghhBBCiOclK1FCCCGEEEIIcQ5SRAkhhBBCCCHEOUgRJYQQQgghhBDnIEWUEEIIIYQQQpyDFFFCCCGEEEIIcQ5SRAkhhBBCCCHEOfw/N0hkQj1feSoAAAAASUVORK5CYII=\n",
            "text/plain": [
              "<Figure size 1080x1080 with 10 Axes>"
            ]
          },
          "metadata": {}
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch ID=0 Batch ID=100 \n",
            "\n",
            " D-Loss=0.24086979031562805 G-Loss=2.8531622886657715\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 1080x1080 with 10 Axes>"
            ]
          },
          "metadata": {}
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch ID=0 Batch ID=200 \n",
            "\n",
            " D-Loss=0.4167623519897461 G-Loss=2.819507598876953\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 1080x1080 with 10 Axes>"
            ]
          },
          "metadata": {}
        },
        {
          "output_type": "error",
          "ename": "KeyboardInterrupt",
          "evalue": "ignored",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mKeyboardInterrupt\u001b[0m                         Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-33-c1d33075243a>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m     18\u001b[0m     \u001b[0mfake_img\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mnetG\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnoise\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     19\u001b[0m     \u001b[0mlabel\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mpaddle\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfull\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mbs_size\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mfake_label\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mdtype\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m'float32'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 20\u001b[0;31m     \u001b[0mfake_out\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mnetD\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfake_img\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdetach\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     21\u001b[0m     \u001b[0merrD_fake\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mloss\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfake_out\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mlabel\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     22\u001b[0m     \u001b[0merrD_fake\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mbackward\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/paddle/fluid/dygraph/layers.py\u001b[0m in \u001b[0;36m__call__\u001b[0;34m(self, *inputs, **kwargs)\u001b[0m\n\u001b[1;32m    900\u001b[0m                 \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_built\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mTrue\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    901\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 902\u001b[0;31m             \u001b[0moutputs\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mforward\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0minputs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    903\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    904\u001b[0m             \u001b[0;32mfor\u001b[0m \u001b[0mforward_post_hook\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_forward_post_hooks\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mvalues\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m<ipython-input-13-f296c45f5b95>\u001b[0m in \u001b[0;36mforward\u001b[0;34m(self, x)\u001b[0m\n\u001b[1;32m     21\u001b[0m     )\n\u001b[1;32m     22\u001b[0m   \u001b[0;32mdef\u001b[0m \u001b[0mforward\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 23\u001b[0;31m     \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdis\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     24\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     25\u001b[0m \u001b[0mnetD\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mDiscriminator\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/paddle/fluid/dygraph/layers.py\u001b[0m in \u001b[0;36m__call__\u001b[0;34m(self, *inputs, **kwargs)\u001b[0m\n\u001b[1;32m    900\u001b[0m                 \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_built\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mTrue\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    901\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 902\u001b[0;31m             \u001b[0moutputs\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mforward\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0minputs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    903\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    904\u001b[0m             \u001b[0;32mfor\u001b[0m \u001b[0mforward_post_hook\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_forward_post_hooks\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mvalues\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/paddle/fluid/dygraph/container.py\u001b[0m in \u001b[0;36mforward\u001b[0;34m(self, input)\u001b[0m\n\u001b[1;32m     96\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mforward\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0minput\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     97\u001b[0m         \u001b[0;32mfor\u001b[0m \u001b[0mlayer\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_sub_layers\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mvalues\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 98\u001b[0;31m             \u001b[0minput\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mlayer\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0minput\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     99\u001b[0m         \u001b[0;32mreturn\u001b[0m \u001b[0minput\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    100\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/paddle/fluid/dygraph/layers.py\u001b[0m in \u001b[0;36m__call__\u001b[0;34m(self, *inputs, **kwargs)\u001b[0m\n\u001b[1;32m    900\u001b[0m                 \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_built\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mTrue\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    901\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 902\u001b[0;31m             \u001b[0moutputs\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mforward\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0minputs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    903\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    904\u001b[0m             \u001b[0;32mfor\u001b[0m \u001b[0mforward_post_hook\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_forward_post_hooks\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mvalues\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/paddle/nn/layer/conv.py\u001b[0m in \u001b[0;36mforward\u001b[0;34m(self, x)\u001b[0m\n\u001b[1;32m    665\u001b[0m             \u001b[0mchannel_dim\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_channel_dim\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    666\u001b[0m             \u001b[0mop_type\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_op_type\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 667\u001b[0;31m             use_cudnn=self._use_cudnn)\n\u001b[0m\u001b[1;32m    668\u001b[0m         \u001b[0;32mreturn\u001b[0m \u001b[0mout\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    669\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/paddle/nn/functional/conv.py\u001b[0m in \u001b[0;36m_conv_nd\u001b[0;34m(x, weight, bias, stride, padding, padding_algorithm, dilation, groups, data_format, channel_dim, op_type, use_cudnn, use_mkldnn, name)\u001b[0m\n\u001b[1;32m    112\u001b[0m                  \u001b[0;34m\"padding_algorithm\"\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mpadding_algorithm\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m\"data_format\"\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    113\u001b[0m                  data_format)\n\u001b[0;32m--> 114\u001b[0;31m         \u001b[0mpre_bias\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mgetattr\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mcore\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mops\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mop_type\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mweight\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0mattrs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    115\u001b[0m         \u001b[0;32mif\u001b[0m \u001b[0mbias\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    116\u001b[0m             \u001b[0mout\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnn\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0melementwise_add\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mpre_bias\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mbias\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0maxis\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mchannel_dim\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;31mKeyboardInterrupt\u001b[0m: "
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "t7o9lhbYC6oi"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    }
  ]
}